Merge pull request #199 from 9seconds/update-lint

Update golangci-lint to 1.41.1

.github/workflows/ci.yaml

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

Makefile

 IMAGE_NAME   := mtg
 APP_NAME     := $(IMAGE_NAME)
 
-GOLANGCI_LINT_VERSION := v1.40.1
+GOLANGCI_LINT_VERSION := v1.41.1
 
 VERSION_GO         := $(shell go version)
 VERSION_DATE       := $(shell date -Ru)

internal/cli/run_proxy.go

 }
 
 func makeEventStream(conf *config.Config, logger mtglib.Logger) (mtglib.EventStream, error) {
-	factories := make([]events.ObserverFactory, 0, 2)
+	factories := make([]events.ObserverFactory, 0, 2) // nolint: gomnd
 
 	if conf.Stats.StatsD.Enabled.Get(false) {
 		statsdFactory, err := stats.NewStatsd(

internal/cli/simple_run.go

 		return fmt.Errorf("incorrect secret: %w", err)
 	}
 
-	if err := conf.Concurrency.Set(strconv.FormatUint(s.Concurrency, 10)); err != nil {
+	if err := conf.Concurrency.Set(strconv.FormatUint(s.Concurrency, 10)); err != nil { // nolint: gomnd
 		return fmt.Errorf("incorrect concurrency: %w", err)
 	}
 
 		return fmt.Errorf("incorrect prefer-ip: %w", err)
 	}
 
-	if err := conf.DomainFrontingPort.Set(strconv.FormatUint(s.DomainFrontingPort, 10)); err != nil {
+	if err := conf.DomainFrontingPort.Set(strconv.FormatUint(s.DomainFrontingPort, 10)); err != nil { // nolint: gomnd
 		return fmt.Errorf("incorrect domain-fronting-port: %w", err)
 	}
 
 
 	conf.Debug.Value = s.Debug
 	conf.Defense.AntiReplay.Enabled.Value = true
-	conf.Defense.Blocklist.Enabled.Value = false
-	conf.Stats.StatsD.Enabled.Value = false
-	conf.Stats.Prometheus.Enabled.Value = false
 
 	if err := conf.Validate(); err != nil {
 		return fmt.Errorf("invalid result configuration: %w", err)

internal/config/type_concurrency.go

 }
 
 func (t *TypeConcurrency) Set(value string) error {
-	concurrencyValue, err := strconv.ParseUint(value, 10, 64)
+	concurrencyValue, err := strconv.ParseUint(value, 10, 16) // nolint: gomnd
 	if err != nil {
 		return fmt.Errorf("value is not uint (%s): %w", value, err)
 	}
 }
 
 func (t TypeConcurrency) String() string {
-	return strconv.FormatUint(uint64(t.Value), 10)
+	return strconv.FormatUint(uint64(t.Value), 10) // nolint: gomnd
 }

internal/config/type_error_rate.go

 }
 
 func (t *TypeErrorRate) Set(value string) error {
-	parsedValue, err := strconv.ParseFloat(value, 64)
+	parsedValue, err := strconv.ParseFloat(value, 64) // nolint: gomnd
 	if err != nil {
 		return fmt.Errorf("value is not a float (%s): %w", value, err)
 	}
 }
 
 func (t TypeErrorRate) String() string {
-	return strconv.FormatFloat(t.Value, 'f', -1, 64)
+	return strconv.FormatFloat(t.Value, 'f', -1, 64) // nolint: gomnd
 }

internal/config/type_hostport.go

 		return fmt.Errorf("incorrect host:port value (%v): %w", value, err)
 	}
 
-	portValue, err := strconv.ParseUint(port, 10, 16)
+	portValue, err := strconv.ParseUint(port, 10, 16) // nolint: gomnd
 	if err != nil {
 		return fmt.Errorf("incorrect port number (%v): %w", value, err)
 	}

internal/config/type_port.go

 }
 
 func (t *TypePort) Set(value string) error {
-	portValue, err := strconv.ParseUint(value, 10, 16)
+	portValue, err := strconv.ParseUint(value, 10, 16) // nolint: gomnd
 	if err != nil {
 		return fmt.Errorf("incorrect port number (%v): %w", value, err)
 	}

ipblocklist/firehol.go

 }
 
 func (f *Firehol) containsIPv4(addr net.IP) bool {
-	ip := patricia.NewIPv4AddressFromBytes(addr, 32)
+	ip := patricia.NewIPv4AddressFromBytes(addr, 32) // nolint: gomnd
 
 	if ok, _, err := f.treeV4.FindDeepestTag(ip); ok && err == nil {
 		return true
 }
 
 func (f *Firehol) containsIPv6(addr net.IP) bool {
-	ip := patricia.NewIPv6Address(addr, 128)
+	ip := patricia.NewIPv6Address(addr, 128) // nolint: gomnd
 
 	if ok, _, err := f.treeV6.FindDeepestTag(ip); ok && err == nil {
 		return true

network/proxy_dialer.go

 	)
 
 	if param := params.Get("open_threshold"); param != "" {
-		if intNum, err := strconv.ParseUint(param, 10, 32); err == nil {
+		if intNum, err := strconv.ParseUint(param, 10, 32); err == nil { // nolint: gomnd
 			openThreshold = uint32(intNum)
 		}
 	}

stats/prometheus.go

 }
 
 func (p prometheusProcessor) Shutdown() {
-	for _, v := range p.streams {
+	for k, v := range p.streams {
 		releaseStreamInfo(v)
+		delete(p.streams, k)
 	}
-
-	p.streams = make(map[string]*streamInfo)
 }
 
 // PrometheusFactory is a factory of events.Observers which collect