Rename metrics

stats/init.go

 	DefaultStatsdMetricPrefix = DefaultMetricPrefix + "."
 	DefaultStatsdTagFormat    = "datadog"
 
-	MetricClientConnections           = "client_connections"
-	MetricTelegramConnections         = "telegram_connections"
-	MetricDomainDisguisingConnections = "domain_disguising_connections"
+	MetricClientConnections         = "client_connections"
+	MetricTelegramConnections       = "telegram_connections"
+	MetricDomainFrontingConnections = "domain_fronting_connections"
 
-	MetricTelegramTraffic         = "telegram_traffic"
-	MetricDomainDisguisingTraffic = "domain_disguising_traffic"
+	MetricTelegramTraffic       = "telegram_traffic"
+	MetricDomainFrontingTraffic = "domain_fronting_traffic"
 
-	MetricDomainDisguising   = "domain_disguising"
+	MetricDomainFronting     = "domain_fronting"
 	MetricConcurrencyLimited = "concurrency_limited"
 	MetricIPBlocklisted      = "ip_blocklisted"
 	MetricReplayAttacks      = "replay_attacks"

stats/pools.go

 
 var streamInfoPool = sync.Pool{
 	New: func() interface{} {
-		return &streamInfo{
-			tags: map[string]string{},
-		}
+		return streamInfo{}
 	},
 }
 
-func acquireStreamInfo() *streamInfo {
-	return streamInfoPool.Get().(*streamInfo)
+func acquireStreamInfo() streamInfo {
+	return streamInfoPool.Get().(streamInfo)
 }
 
-func releaseStreamInfo(info *streamInfo) {
+func releaseStreamInfo(info streamInfo) {
 	info.Reset()
 	streamInfoPool.Put(info)
 }

stats/prometheus.go

 	"context"
 	"net"
 	"net/http"
+	"strconv"
 
 	"github.com/9seconds/mtg/v2/events"
 	"github.com/9seconds/mtg/v2/mtglib"
 )
 
 type prometheusProcessor struct {
-	streams map[string]*streamInfo
+	streams map[string]streamInfo
 	factory *PrometheusFactory
 }
 
 func (p prometheusProcessor) EventStart(evt mtglib.EventStart) {
 	info := acquireStreamInfo()
-	info.SetStartTime(evt.CreatedAt)
-	info.SetClientIP(evt.RemoteIP)
+
+	if evt.RemoteIP.To4() != nil {
+		info[TagIPFamily] = TagIPFamilyIPv4
+	} else {
+		info[TagIPFamily] = TagIPFamilyIPv6
+	}
+
 	p.streams[evt.StreamID()] = info
 
 	p.factory.metricClientConnections.
-		WithLabelValues(info.V(TagIPFamily)).
+		WithLabelValues(info[TagIPFamily]).
 		Inc()
 }
 
 		return
 	}
 
-	info.SetTelegramIP(evt.RemoteIP)
-	info.SetDC(evt.DC)
+	info[TagTelegramIP] = evt.RemoteIP.String()
+	info[TagDC] = strconv.Itoa(evt.DC)
 
 	p.factory.metricTelegramConnections.
-		WithLabelValues(info.V(TagTelegramIP), info.V(TagDC)).
+		WithLabelValues(info[TagTelegramIP], info[TagDC]).
 		Inc()
 }
 
 	}
 
 	p.factory.metricTelegramTraffic.
-		WithLabelValues(info.V(TagTelegramIP), info.V(TagDC), getDirection(evt.IsRead)).
+		WithLabelValues(info[TagTelegramIP], info[TagDC], getDirection(evt.IsRead)).
 		Add(float64(evt.Traffic))
 }
 
 	}()
 
 	p.factory.metricClientConnections.
-		WithLabelValues(info.V(TagIPFamily)).
+		WithLabelValues(info[TagIPFamily]).
 		Dec()
 
-	if info.V(TagTelegramIP) != "" {
+	if telegramIP, ok := info[TagTelegramIP]; ok {
 		p.factory.metricTelegramConnections.
-			WithLabelValues(info.V(TagTelegramIP), info.V(TagDC)).
+			WithLabelValues(telegramIP, info[TagDC]).
 			Dec()
 	}
 }
 }
 
 func (p prometheusProcessor) Shutdown() {
-	p.streams = make(map[string]*streamInfo)
+	p.streams = make(map[string]streamInfo)
 }
 
 type PrometheusFactory struct {
 	httpServer *http.Server
 
-	metricClientConnections           *prometheus.GaugeVec
-	metricTelegramConnections         *prometheus.GaugeVec
-	metricDomainDisguisingConnections *prometheus.GaugeVec
+	metricClientConnections         *prometheus.GaugeVec
+	metricTelegramConnections       *prometheus.GaugeVec
+	metricDomainFrontingConnections *prometheus.GaugeVec
 
-	metricTelegramTraffic         *prometheus.CounterVec
-	metricDomainDisguisingTraffic *prometheus.CounterVec
+	metricTelegramTraffic       *prometheus.CounterVec
+	metricDomainFrontingTraffic *prometheus.CounterVec
 
-	metricDomainDisguising   prometheus.Counter
+	metricDomainFronting     prometheus.Counter
 	metricConcurrencyLimited prometheus.Counter
 	metricIPBlocklisted      prometheus.Counter
 	metricReplayAttacks      prometheus.Counter
 
 func (p *PrometheusFactory) Make() events.Observer {
 	return prometheusProcessor{
-		streams: make(map[string]*streamInfo),
+		streams: make(map[string]streamInfo),
 		factory: p,
 	}
 }
 			Name:      MetricTelegramConnections,
 			Help:      "A number of connections to Telegram servers.",
 		}, []string{TagTelegramIP, TagDC}),
-		metricDomainDisguisingConnections: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		metricDomainFrontingConnections: prometheus.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: metricPrefix,
-			Name:      MetricDomainDisguisingConnections,
-			Help:      "A number of connections which talk with disguising domain.",
+			Name:      MetricDomainFronting,
+			Help:      "A number of connections which talk with front domain.",
 		}, []string{TagIPFamily}),
 
 		metricTelegramTraffic: prometheus.NewCounterVec(prometheus.CounterOpts{
 			Name:      MetricTelegramTraffic,
 			Help:      "Traffic which is generated talking with Telegram servers.",
 		}, []string{TagTelegramIP, TagDC, TagDirection}),
-		metricDomainDisguisingTraffic: prometheus.NewCounterVec(prometheus.CounterOpts{
+		metricDomainFrontingTraffic: prometheus.NewCounterVec(prometheus.CounterOpts{
 			Namespace: metricPrefix,
-			Name:      MetricDomainDisguisingTraffic,
-			Help:      "Traffic which is generated talking with disguising domain.",
+			Name:      MetricDomainFrontingTraffic,
+			Help:      "Traffic which is generated talking with front domain.",
 		}, []string{TagDirection}),
 
-		metricDomainDisguising: prometheus.NewCounter(prometheus.CounterOpts{
+		metricDomainFronting: prometheus.NewCounter(prometheus.CounterOpts{
 			Namespace: metricPrefix,
-			Name:      MetricDomainDisguising,
-			Help:      "A number of routings to disguising domain.",
+			Name:      MetricDomainFronting,
+			Help:      "A number of routings to front domain.",
 		}),
 		metricConcurrencyLimited: prometheus.NewCounter(prometheus.CounterOpts{
 			Namespace: metricPrefix,
 
 	registry.MustRegister(factory.metricClientConnections)
 	registry.MustRegister(factory.metricTelegramConnections)
-	registry.MustRegister(factory.metricDomainDisguisingConnections)
+	registry.MustRegister(factory.metricDomainFrontingConnections)
 
 	registry.MustRegister(factory.metricTelegramTraffic)
-	registry.MustRegister(factory.metricDomainDisguisingTraffic)
+	registry.MustRegister(factory.metricDomainFrontingTraffic)
 
-	registry.MustRegister(factory.metricDomainDisguising)
+	registry.MustRegister(factory.metricDomainFronting)
 	registry.MustRegister(factory.metricConcurrencyLimited)
 	registry.MustRegister(factory.metricIPBlocklisted)
 	registry.MustRegister(factory.metricReplayAttacks)

stats/statsd.go

 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 	"time"
 
 )
 
 type statsdProcessor struct {
-	streams map[string]*streamInfo
+	streams map[string]streamInfo
 	client  *statsd.Client
 }
 
 func (s statsdProcessor) EventStart(evt mtglib.EventStart) {
 	info := acquireStreamInfo()
-	info.SetStartTime(evt.CreatedAt)
-	info.SetClientIP(evt.RemoteIP)
+
+	if evt.RemoteIP.To4() != nil {
+		info[TagIPFamily] = TagIPFamilyIPv4
+	} else {
+		info[TagIPFamily] = TagIPFamilyIPv6
+	}
+
 	s.streams[evt.StreamID()] = info
 
 	s.client.GaugeDelta(MetricClientConnections,
 		1,
-		info.TV(TagIPFamily))
+		info.T(TagIPFamily))
 }
 
 func (s statsdProcessor) EventConnectedToDC(evt mtglib.EventConnectedToDC) {
 		return
 	}
 
-	info.SetTelegramIP(evt.RemoteIP)
-	info.SetDC(evt.DC)
+	info[TagTelegramIP] = evt.RemoteIP.String()
+	info[TagDC] = strconv.Itoa(evt.DC)
 
 	s.client.GaugeDelta(MetricTelegramConnections,
 		1,
-		info.TV(TagTelegramIP),
-		info.TV(TagDC))
+		info.T(TagTelegramIP),
+		info.T(TagDC))
 }
 
 func (s statsdProcessor) EventTraffic(evt mtglib.EventTraffic) {
 
 	s.client.Incr(MetricTelegramTraffic,
 		int64(evt.Traffic),
-		info.TV(TagTelegramIP),
-		info.TV(TagDC),
+		info.T(TagTelegramIP),
+		info.T(TagDC),
 		statsd.StringTag(TagDirection, getDirection(evt.IsRead)))
 }
 
 
 	s.client.GaugeDelta(MetricClientConnections,
 		-1,
-		info.TV(TagIPFamily))
+		info.T(TagIPFamily))
 
-	if info.V(TagTelegramIP) != "" {
+	if _, ok := info[TagTelegramIP]; ok {
 		s.client.GaugeDelta(MetricTelegramConnections,
 			-1,
-			info.TV(TagTelegramIP),
-			info.TV(TagDC))
+			info.T(TagTelegramIP),
+			info.T(TagDC))
 	}
 }
 
 func (s StatsdFactory) Make() events.Observer {
 	return statsdProcessor{
 		client:  s.client,
-		streams: make(map[string]*streamInfo),
+		streams: make(map[string]streamInfo),
 	}
 }
 

stats/stream_info.go

 package stats
 
-import (
-	"net"
-	"strconv"
-	"time"
+import statsd "github.com/smira/go-statsd"
 
-	statsd "github.com/smira/go-statsd"
-)
+type streamInfo map[string]string
 
-type streamInfo struct {
-	startTime time.Time
-	tags      map[string]string
+func (s streamInfo) T(key string) statsd.Tag {
+	return statsd.StringTag(key, s[key])
 }
 
-func (s *streamInfo) SetStartTime(tme time.Time) {
-	s.startTime = tme
-}
-
-func (s *streamInfo) SetClientIP(ip net.IP) {
-	if ip.To4() != nil {
-		s.tags[TagIPFamily] = TagIPFamilyIPv4
-	} else {
-		s.tags[TagIPFamily] = TagIPFamilyIPv6
-	}
-}
-
-func (s *streamInfo) SetTelegramIP(ip net.IP) {
-	s.tags[TagTelegramIP] = ip.String()
-}
-
-func (s *streamInfo) SetDC(dc int) {
-	s.tags[TagDC] = strconv.Itoa(dc)
-}
-
-func (s *streamInfo) V(key string) string {
-	return s.tags[key]
-}
-
-func (s *streamInfo) TV(key string) statsd.Tag {
-	return statsd.StringTag(key, s.tags[key])
-}
-
-func (s *streamInfo) Reset() {
-	s.startTime = time.Time{}
-
-	for k := range s.tags {
-		delete(s.tags, k)
+func (s streamInfo) Reset() {
+	for k := range s {
+		delete(s, k)
 	}
 }