Update golanci-lint

.github/workflows/ci.yaml

       - name: Run linter
         uses: golangci/golangci-lint-action@v2
         with:
-          version: v1.37.1
+          version: v1.39.0
 
   docker:
     name: Docker

.golangci.toml

 deadline = "2m"
 tests = true
 skip-dirs = ["vendor"]
-skip-files = ["version.go"]
 
 [output]
 format = "colored-line-number"

Makefile

 
 CC_BINARIES  := $(shell bash -c "echo -n $(APP_NAME)-{linux,freebsd,openbsd}-{386,amd64} $(APP_NAME)-linux-{arm,arm64}")
 
-GOLANGCI_LINT_VERSION := v1.37.1
+GOLANGCI_LINT_VERSION := v1.39.0
 
 VERSION_GO         := $(shell go version)
 VERSION_DATE       := $(shell date -Ru)

events/event_stream_test.go

 			On("EventStart", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventStart)
+				caught, ok := args.Get(0).(mtglib.EventStart)
 
+				suite.True(ok)
 				suite.Equal(evt.RemoteIP.String(), caught.RemoteIP.String())
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 			On("EventConnectedToDC", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventConnectedToDC)
+				caught, ok := args.Get(0).(mtglib.EventConnectedToDC)
 
+				suite.True(ok)
 				suite.Equal(evt.RemoteIP.String(), caught.RemoteIP.String())
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.DC, caught.DC)
 			On("EventDomainFronting", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventDomainFronting)
+				caught, ok := args.Get(0).(mtglib.EventDomainFronting)
 
+				suite.True(ok)
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 			})
 			On("EventTraffic", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventTraffic)
+				caught, ok := args.Get(0).(mtglib.EventTraffic)
 
+				suite.True(ok)
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 				suite.Equal(evt.Traffic, caught.Traffic)
 			On("EventFinish", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventFinish)
+				caught, ok := args.Get(0).(mtglib.EventFinish)
 
+				suite.True(ok)
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 			})
 			On("EventConcurrencyLimited", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventConcurrencyLimited)
+				caught, ok := args.Get(0).(mtglib.EventConcurrencyLimited)
 
+				suite.True(ok)
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 				suite.Empty(evt.StreamID())
 			})
 			On("EventIPBlocklisted", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventIPBlocklisted)
+				caught, ok := args.Get(0).(mtglib.EventIPBlocklisted)
 
+				suite.True(ok)
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 				suite.Equal(evt.RemoteIP.String(), caught.RemoteIP.String())
 			On("EventReplayAttack", mock.Anything).
 			Once().
 			Run(func(args mock.Arguments) {
-				caught := args.Get(0).(mtglib.EventReplayAttack)
+				caught, ok := args.Get(0).(mtglib.EventReplayAttack)
 
+				suite.True(ok)
 				suite.Equal(evt.StreamID(), caught.StreamID())
 				suite.Equal(evt.Timestamp(), caught.Timestamp())
 			})

go.mod

 	github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5
 	github.com/babolivier/go-doh-client v0.0.0-20201028162107-a76cff4cb8b6
 	github.com/d4l3k/messagediff v1.2.1 // indirect
+	github.com/google/go-cmp v0.5.5 // indirect
 	github.com/jarcoal/httpmock v1.0.8
 	github.com/kentik/patricia v0.0.0-20201202224819-f9447a6e25f1
 	github.com/libp2p/go-reuseport v0.0.2
 	github.com/tylertreat/BoomFilters v0.0.0-20200520150052-42a7b4300c0c
 	github.com/xeipuuv/gojsonschema v1.2.0
 	golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2
-	golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
-	golang.org/x/sys v0.0.0-20210309074719-68d13333faf2
+	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
+	golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )

go.sum

 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110 h1:qWPm9rbaAMKs8Bq/9LRpbMqxWRVUAQwMI9fVrssnTfw=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
-golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57 h1:F5Gozwx4I1xtr/sr/8CFbb57iKi3297KFs0QDbGN60A=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=

internal/cli/access.go

 
 func (c *Access) getIP(protocol string) net.IP {
 	client := c.Network.MakeHTTPClient(func(ctx context.Context, network, address string) (net.Conn, error) {
-		return c.Network.DialContext(ctx, protocol, address)
+		return c.Network.DialContext(ctx, protocol, address) // nolint: wrapcheck
 	})
 
 	req, err := http.NewRequest(http.MethodGet, "https://ifconfig.co", nil) // nolint: noctx

internal/cli/base.go

 
 	switch len(proxyURLs) {
 	case 0:
-		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout)
+		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout) // nolint: wrapcheck
 	case 1:
 		socksDialer, err := network.NewSocks5Dialer(baseDialer, proxyURLs[0])
 		if err != nil {
 			return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 		}
 
-		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout)
+		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) // nolint: wrapcheck
 	}
 
 	socksDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, proxyURLs)
 		return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 	}
 
-	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout)
+	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) // nolint: wrapcheck
 }

internal/testlib/mtglib_network_mock.go

 func (m *MtglibNetworkMock) Dial(network, address string) (net.Conn, error) {
 	args := m.Called(network, address)
 
-	return args.Get(0).(net.Conn), args.Error(1)
+	return args.Get(0).(net.Conn), args.Error(1) // nolint: wrapcheck
 }
 
 func (m *MtglibNetworkMock) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	args := m.Called(ctx, network, address)
 
-	return args.Get(0).(net.Conn), args.Error(1)
+	return args.Get(0).(net.Conn), args.Error(1) // nolint: wrapcheck
 }
 
 func (m *MtglibNetworkMock) MakeHTTPClient(dialFunc func(ctx context.Context,

internal/testlib/net_conn_mock.go

 }
 
 func (n *NetConnMock) Close() error {
-	return n.Called().Error(0)
+	return n.Called().Error(0) // nolint: wrapcheck
 }
 
 func (n *NetConnMock) LocalAddr() net.Addr {
 }
 
 func (n *NetConnMock) SetDeadline(t time.Time) error {
-	return n.Called(t).Error(0)
+	return n.Called(t).Error(0) // nolint: wrapcheck
 }
 
 func (n *NetConnMock) SetReadDeadline(t time.Time) error {
-	return n.Called(t).Error(0)
+	return n.Called(t).Error(0) // nolint: wrapcheck
 }
 
 func (n *NetConnMock) SetWriteDeadline(t time.Time) error {
-	return n.Called(t).Error(0)
+	return n.Called(t).Error(0) // nolint: wrapcheck
 }

ipblocklist/firehol.go

 		return true
 	}
 
-	ip4 := ip.To4()
-
 	f.rwMutex.RLock()
 	defer f.rwMutex.RUnlock()
 
-	if ip4 != nil {
+	if ip4 := ip.To4(); ip4 != nil {
 		return f.containsIPv4(ip4)
 	}
 

mtglib/conns.go

 	c.mutex.RLock()
 	defer c.mutex.RUnlock()
 
-	return c.active.Read(p)
+	return c.active.Read(p) // nolint: wrapcheck
 }
 
 func (c *connRewind) Rewind() {

mtglib/conns_internal_test.go

 func (c *ConnRewindBaseConn) Read(p []byte) (int, error) {
 	c.Called(p)
 
-	return c.readBuffer.Read(p)
+	return c.readBuffer.Read(p) // nolint: wrapcheck
 }
 
 type ConnTrafficTestSuite struct {
 		On("Send", mock.Anything, mock.Anything).
 		Once().
 		Run(func(args mock.Arguments) {
-			evt := args.Get(1).(EventTraffic)
+			evt, ok := args.Get(1).(EventTraffic)
 
+			suite.True(ok)
 			suite.Equal("CONNID", evt.StreamID())
 			suite.WithinDuration(time.Now(), evt.Timestamp(), time.Second)
 			suite.EqualValues(10, evt.Traffic)
 	suite.Equal(10, n)
 }
 
-func (suite *ConnTrafficTestSuite) TestReadErr() {
+func (suite *ConnTrafficTestSuite) TestReadErr() { // nolint: dupl
 	suite.eventStreamMock.
 		On("Send", mock.Anything, mock.Anything).
 		Once().
 		Run(func(args mock.Arguments) {
-			evt := args.Get(1).(EventTraffic)
+			evt, ok := args.Get(1).(EventTraffic)
 
+			suite.True(ok)
 			suite.Equal("CONNID", evt.StreamID())
 			suite.WithinDuration(time.Now(), evt.Timestamp(), time.Second)
 			suite.EqualValues(10, evt.Traffic)
 		On("Send", mock.Anything, mock.Anything).
 		Once().
 		Run(func(args mock.Arguments) {
-			evt := args.Get(1).(EventTraffic)
+			evt, ok := args.Get(1).(EventTraffic)
 
+			suite.True(ok)
 			suite.Equal("CONNID", evt.StreamID())
 			suite.WithinDuration(time.Now(), evt.Timestamp(), time.Second)
 			suite.EqualValues(10, evt.Traffic)
 	suite.Equal(10, n)
 }
 
-func (suite *ConnTrafficTestSuite) TestWriteErr() {
+func (suite *ConnTrafficTestSuite) TestWriteErr() { // nolint: dupl
 	suite.eventStreamMock.
 		On("Send", mock.Anything, mock.Anything).
 		Once().
 		Run(func(args mock.Arguments) {
-			evt := args.Get(1).(EventTraffic)
+			evt, ok := args.Get(1).(EventTraffic)
 
+			suite.True(ok)
 			suite.Equal("CONNID", evt.StreamID())
 			suite.WithinDuration(time.Now(), evt.Timestamp(), time.Second)
 			suite.EqualValues(10, evt.Traffic)

mtglib/internal/faketls/conn.go

 		case record.TypeApplicationData:
 			rec.Payload.WriteTo(&c.readBuffer) // nolint: errcheck
 
-			return c.readBuffer.Read(p)
+			return c.readBuffer.Read(p) // nolint: wrapcheck
 		case record.TypeChangeCipherSpec:
 		default:
 			return 0, fmt.Errorf("unsupported record type %v", rec.Type)

mtglib/internal/faketls/conn_test.go

 func (m *ConnMock) Read(p []byte) (int, error) {
 	m.Called(p)
 
-	return m.readBuffer.Read(p)
+	return m.readBuffer.Read(p) // nolint: wrapcheck
 }
 
 func (m *ConnMock) Write(p []byte) (int, error) {
 	m.Called(p)
 
-	return m.writeBuffer.Write(p)
+	return m.writeBuffer.Write(p) // nolint: wrapcheck
 }
 
 type ConnTestSuite struct {

mtglib/internal/faketls/welcome.go

 	packet := buf.Bytes()
 	mac := hmac.New(sha256.New, secret)
 
-	mac.Write(clientHello.Random[:]) // nolint: errcheck
-	mac.Write(packet)                // nolint: errcheck
+	mac.Write(clientHello.Random[:])
+	mac.Write(packet)
 
 	copy(packet[WelcomePacketRandomOffset:], mac.Sum(nil))
 

mtglib/internal/faketls/welcome_test.go

 	copy(welcomePacket[11:], empty)
 
 	mac := hmac.New(sha256.New, suite.secret.Key[:])
-	mac.Write(suite.h.Random[:]) // nolint: errcheck
-	mac.Write(welcomePacket)     // nolint: errcheck
+	mac.Write(suite.h.Random[:])
+	mac.Write(welcomePacket)
 
 	suite.Equal(random, mac.Sum(nil))
 }

mtglib/internal/obfuscated2/client_handshake.go

 	hasher := acquireSha256Hasher()
 	defer releaseSha256Hasher(hasher)
 
-	hasher.Write(c.key()) // nolint: errcheck
-	hasher.Write(secret)  // nolint: errcheck
+	hasher.Write(c.key())
+	hasher.Write(secret)
 
 	return makeAesCtr(hasher.Sum(nil), c.iv())
 }
 	hasher := acquireSha256Hasher()
 	defer releaseSha256Hasher(hasher)
 
-	hasher.Write(invertedHandshake.key()) // nolint: errcheck
-	hasher.Write(secret)                  // nolint: errcheck
+	hasher.Write(invertedHandshake.key())
+	hasher.Write(secret)
 
 	return makeAesCtr(hasher.Sum(nil), invertedHandshake.iv())
 }

mtglib/internal/obfuscated2/client_handshake_test.go

 				Once().
 				Return(len(snapshot.Decrypted.Text.data), nil).
 				Run(func(args mock.Arguments) {
-					arr := args.Get(0).([]byte)
+					arr, ok := args.Get(0).([]byte)
+
+					suite.True(ok)
 					copy(arr, snapshot.Decrypted.Cipher.data)
 				})
 			connMock.On("Write", mock.Anything).
 				Once().
 				Return(len(snapshot.Encrypted.Text.data), nil).
 				Run(func(args mock.Arguments) {
-					arr := args.Get(0).([]byte)
+					arr, ok := args.Get(0).([]byte)
+
+					suite.True(ok)
 					copy(writeData, arr)
 				})
 

mtglib/internal/obfuscated2/conn.go

 	payload := buf.Bytes()
 	c.Encryptor.XORKeyStream(payload, payload)
 
-	return c.Conn.Write(payload)
+	return c.Conn.Write(payload) // nolint: wrapcheck
 }

mtglib/internal/relay/init_test.go

 		return 0, io.EOF
 	}
 
-	return r.Buffer.Read(p)
+	return r.Buffer.Read(p) // nolint: wrapcheck
 }
 
 func (r *rwcMock) Write(p []byte) (int, error) {
 		return 0, io.EOF
 	}
 
-	return r.Buffer.Write(p)
+	return r.Buffer.Write(p) // nolint: wrapcheck
 }
 
 func (r *rwcMock) Close() error {

mtglib/internal/relay/pools.go

 func AcquireRelay(ctx context.Context, logger Logger, bufferSize int, idleTimeout time.Duration) *Relay {
 	ctx, cancel := context.WithCancel(ctx)
 
-	r := relayPool.Get().(*Relay)
+	r, ok := relayPool.Get().(*Relay)
+	if !ok {
+		panic("Relay pool has no relay!")
+	}
+
 	r.ctx = ctx
 	r.ctxCancel = cancel
 	r.logger = logger

mtglib/stream_context.go

 }
 
 func (s *streamContext) Err() error {
-	return s.ctx.Err()
+	return s.ctx.Err() // nolint: wrapcheck
 }
 
 func (s *streamContext) Value(key interface{}) interface{} {

network/circuit_breaker.go

 			conn.Close()
 		}
 
-		return nil, ctx.Err()
+		return nil, ctx.Err() // nolint: wrapcheck
 	case c.stateMutexChan <- true:
 		defer func() {
 			<-c.stateMutexChan
 	if err == nil {
 		c.switchState(circuitBreakerStateClosed)
 
-		return conn, err // nolint: wrapcheck
+		return conn, nil
 	}
 
 	c.failuresCount++
 			conn.Close()
 		}
 
-		return nil, ctx.Err()
+		return nil, ctx.Err() // nolint: wrapcheck
 	case c.stateMutexChan <- true:
 		defer func() {
 			<-c.stateMutexChan

network/default.go

 		return nil, fmt.Errorf("cannot dial to %s: %w", address, err)
 	}
 
-	tcpConn := conn.(*net.TCPConn)
+	tcpConn, ok := conn.(*net.TCPConn)
+	if !ok {
+		panic("conn type is not tcp")
+	}
 
 	if err := tcpConn.SetNoDelay(true); err != nil {
 		conn.Close()

network/init_internal_test.go

 func (d *DialerMock) Dial(network, address string) (net.Conn, error) {
 	args := d.Called(network, address)
 
-	return args.Get(0).(net.Conn), args.Error(1)
+	return args.Get(0).(net.Conn), args.Error(1) // nolint: wrapcheck
 }
 
 func (d *DialerMock) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	args := d.Called(ctx, network, address)
 
-	return args.Get(0).(net.Conn), args.Error(1)
+	return args.Get(0).(net.Conn), args.Error(1) // nolint: wrapcheck
 }

network/init_test.go

 func (d *DialerMock) Dial(network, address string) (net.Conn, error) {
 	args := d.Called(network, address)
 
-	return args.Get(0).(net.Conn), args.Error(1)
+	return args.Get(0).(net.Conn), args.Error(1) // nolint: wrapcheck
 }
 
 func (d *DialerMock) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	args := d.Called(ctx, network, address)
 
-	return args.Get(0).(net.Conn), args.Error(1)
+	return args.Get(0).(net.Conn), args.Error(1) // nolint: wrapcheck
 }
 
 type HTTPServerTestSuite struct {

network/network.go

 func (n networkHTTPTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	req.Header.Set("User-Agent", n.userAgent)
 
-	return n.next.RoundTrip(req)
+	return n.next.RoundTrip(req) // nolint: wrapcheck
 }
 
 type network struct {

network/proxy_dialer_internal_test.go

 }
 
 func (suite *ProxyDialerTestSuite) TestSetupDefaults() {
-	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
+	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
 	suite.EqualValues(ProxyDialerOpenThreshold, d.openThreshold)
 	suite.EqualValues(ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 	suite.EqualValues(ProxyDialerResetFailuresTimeout, d.resetFailuresTimeout)
 	query.Set("half_open_timeout", "2s")
 	suite.u.RawQuery = query.Encode()
 
-	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
+	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
 	suite.EqualValues(30, d.openThreshold)
 	suite.EqualValues(2*time.Second, d.halfOpenTimeout)
 	suite.EqualValues(time.Second, d.resetFailuresTimeout)
 			query.Set("open_threshold", param)
 			suite.u.RawQuery = query.Encode()
 
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
 			assert.EqualValues(t, ProxyDialerOpenThreshold, d.openThreshold)
 		})
 	}
 			query.Set("half_open_timeout", param)
 			suite.u.RawQuery = query.Encode()
 
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
 			assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 		})
 	}
 			query.Set("reset_failures_timeout", param)
 			suite.u.RawQuery = query.Encode()
 
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
 			assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 		})
 	}

stats/prometheus.go

 
 // Serve starts an HTTP server on a given listener.
 func (p *PrometheusFactory) Serve(listener net.Listener) error {
-	return p.httpServer.Serve(listener)
+	return p.httpServer.Serve(listener) // nolint: wrapcheck
 }
 
 // Close stops a factory. Please pay attention that underlying listener
 // is not closed.
 func (p *PrometheusFactory) Close() error {
-	return p.httpServer.Shutdown(context.Background())
+	return p.httpServer.Shutdown(context.Background()) // nolint: wrapcheck
 }
 
 // NewPrometheus builds an events.ObserverFactory which can serve HTTP

stats/statsd.go

 
 // Close stops sending requests to statsd.
 func (s StatsdFactory) Close() error {
-	return s.client.Close()
+	return s.client.Close() // nolint: wrapcheck
 }
 
 // Make build a new observer.

stats/statsd_test.go

 
 func (s *statsdFakeServer) Close() error {
 	if s.conn != nil {
-		return s.conn.Close()
+		return s.conn.Close() // nolint: wrapcheck
 	}
 
 	return nil