Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📁 .circleci	-	2025-05-25 12:27
📄 .gitignore # Compiled Object files, Static and Dynamic libs (Shared Objects) .o .a .so # Folders _obj _test # Architecture specific extensions/prefixes .[568vq] [568vq].out .cgo1.go .cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe /metrics.out .idea	273 B	2025-05-25 12:27
📄 .travis.yml language: go go: - "1.x" env: - GO111MODULE=on install: - go get ./... script: - go test ./...	107 B	2025-05-25 12:27
📄 LICENSE The MIT License (MIT) Copyright (c) 2013 Armon Dadgar Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.	1.05 KB	2025-05-25 12:27
📄 README.md go-metrics ========== This library provides a `metrics` package which can be used to instrument code, expose application metrics, and profile runtime performance in a flexible manner. Current API: [![GoDoc](https://godoc.org/github.com/armon/go-metrics?status.svg)](https://godoc.org/github.com/armon/go-metrics) Sinks ----- The `metrics` package makes use of a `MetricSink` interface to support delivery to any type of backend. Currently the following sinks are provided: * StatsiteSink : Sinks to a [statsite](https://github.com/armon/statsite/) instance (TCP) * StatsdSink: Sinks to a [StatsD](https://github.com/etsy/statsd/) / statsite instance (UDP) * PrometheusSink: Sinks to a [Prometheus](http://prometheus.io/) metrics endpoint (exposed via HTTP for scrapes) * InmemSink : Provides in-memory aggregation, can be used to export stats * FanoutSink : Sinks to multiple sinks. Enables writing to multiple statsite instances for example. * BlackholeSink : Sinks to nowhere In addition to the sinks, the `InmemSignal` can be used to catch a signal, and dump a formatted output of recent metrics. For example, when a process gets a SIGUSR1, it can dump to stderr recent performance metrics for debugging. Labels ------ Most metrics do have an equivalent ending with `WithLabels`, such methods allow to push metrics with labels and use some features of underlying Sinks (ex: translated into Prometheus labels). Since some of these labels may increase greatly cardinality of metrics, the library allow to filter labels using a blacklist/whitelist filtering system which is global to all metrics. * If `Config.AllowedLabels` is not nil, then only labels specified in this value will be sent to underlying Sink, otherwise, all labels are sent by default. * If `Config.BlockedLabels` is not nil, any label specified in this value will not be sent to underlying Sinks. By default, both `Config.AllowedLabels` and `Config.BlockedLabels` are nil, meaning that no tags are filetered at all, but it allow to a user to globally block some tags with high cardinality at application level. Examples -------- Here is an example of using the package: ```go func SlowMethod() { // Profiling the runtime of a method defer metrics.MeasureSince([]string{"SlowMethod"}, time.Now()) } // Configure a statsite sink as the global metrics sink sink, _ := metrics.NewStatsiteSink("statsite:8125") metrics.NewGlobal(metrics.DefaultConfig("service-name"), sink) // Emit a Key/Value pair metrics.EmitKey([]string{"questions", "meaning of life"}, 42) ``` Here is an example of setting up a signal handler: ```go // Setup the inmem sink and signal handler inm := metrics.NewInmemSink(10*time.Second, time.Minute) sig := metrics.DefaultInmemSignal(inm) metrics.NewGlobal(metrics.DefaultConfig("service-name"), inm) // Run some code inm.SetGauge([]string{"foo"}, 42) inm.EmitKey([]string{"bar"}, 30) inm.IncrCounter([]string{"baz"}, 42) inm.IncrCounter([]string{"baz"}, 1) inm.IncrCounter([]string{"baz"}, 80) inm.AddSample([]string{"method", "wow"}, 42) inm.AddSample([]string{"method", "wow"}, 100) inm.AddSample([]string{"method", "wow"}, 22) .... ``` When a signal comes in, output like the following will be dumped to stderr: [2014-01-28 14:57:33.04 -0800 PST][G] 'foo': 42.000 [2014-01-28 14:57:33.04 -0800 PST][P] 'bar': 30.000 [2014-01-28 14:57:33.04 -0800 PST][C] 'baz': Count: 3 Min: 1.000 Mean: 41.000 Max: 80.000 Stddev: 39.509 [2014-01-28 14:57:33.04 -0800 PST][S] 'method.wow': Count: 3 Min: 22.000 Mean: 54.667 Max: 100.000 Stddev: 40.513	3.49 KB	2025-05-25 12:27
📁 circonus	-	2025-05-25 12:27
📄 const_unix.go // +build !windows package metrics import ( "syscall" ) const ( // DefaultSignal is used with DefaultInmemSignal DefaultSignal = syscall.SIGUSR1 )	153 B	2025-05-25 12:27
📄 const_windows.go // +build windows package metrics import ( "syscall" ) const ( // DefaultSignal is used with DefaultInmemSignal // Windows has no SIGUSR1, use SIGBREAK DefaultSignal = syscall.Signal(21) )	196 B	2025-05-25 12:27
📁 datadog	-	2025-05-25 12:27
📄 go.mod module github.com/armon/go-metrics go 1.12 require ( github.com/DataDog/datadog-go v3.2.0+incompatible github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible github.com/circonus-labs/circonusllhist v0.1.3 // indirect github.com/golang/protobuf v1.3.2 github.com/hashicorp/go-immutable-radix v1.0.0 github.com/hashicorp/go-retryablehttp v0.5.3 // indirect github.com/pascaldekloe/goe v0.1.0 github.com/prometheus/client_golang v1.4.0 github.com/prometheus/client_model v0.2.0 github.com/prometheus/common v0.9.1 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926 // indirect )	607 B	2025-05-25 12:27
📄 go.sum github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4= github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible h1:C29Ae4G5GtYyYMm1aztcyj/J5ckgJm2zwdDajFbx1NY= github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= github.com/circonus-labs/circonusllhist v0.1.3 h1:TJH+oke8D16535+jHExHj4nQvzlZrj7ug5D7I/orNUA= github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= 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/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/hashicorp/go-cleanhttp v0.5.0 h1:wvCrVc9TjDls6+YGAF2hAifE1E5U1+b4tH6KdvN3Gig= github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-immutable-radix v1.0.0 h1:AKDB1HM5PWEA7i4nhcpwOrO2byshxBjXVn/J/3+z5/0= github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= github.com/hashicorp/go-retryablehttp v0.5.3 h1:QlWt0KvWT0lq8MFppF9tsJGF+ynG7ztc2KIPhzRGk7s= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-uuid v1.0.0 h1:RS8zrF7PhGwyNPOtxSClXXj9HA8feRnJzgnI1RJCSnM= github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY= github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= github.com/prometheus/client_golang v1.4.0 h1:YVIb/fVcOTMSqtqZWSKnHpSLBxu8DKgxq8z6RuBZwqI= github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.9.1 h1:KOMtN28tlbam3/7ZKEYKHhKoJZYYj3gMH4uc62x7X7U= github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.8 h1:+fpWZdT24pJBiqJdAwYBjPSk+5YmQzYNPYzQsdzLkt8= github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926 h1:G3dpKMzFDjgEh2q1Z7zUUtKa8ViPtH+ocF0bE0g00O8= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82 h1:ywK/j/KkyTHcdyYSZNXGjMwgmDSfjglYZ3vStQ/gSCU= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 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= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5 h1:ymVxjfMaHvXD8RqPRmzHHsB3VvucivSkIAvJFDI5O3c= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=	11.68 KB	2025-05-25 12:27
📄 inmem.go package metrics import ( "bytes" "fmt" "math" "net/url" "strings" "sync" "time" ) var spaceReplacer = strings.NewReplacer(" ", "_") // InmemSink provides a MetricSink that does in-memory aggregation // without sending metrics over a network. It can be embedded within // an application to provide profiling information. type InmemSink struct { // How long is each aggregation interval interval time.Duration // Retain controls how many metrics interval we keep retain time.Duration // maxIntervals is the maximum length of intervals. // It is retain / interval. maxIntervals int // intervals is a slice of the retained intervals intervals []IntervalMetrics intervalLock sync.RWMutex rateDenom float64 } // IntervalMetrics stores the aggregated metrics // for a specific interval type IntervalMetrics struct { sync.RWMutex // The start time of the interval Interval time.Time // Gauges maps the key to the last set value Gauges map[string]GaugeValue // Points maps the string to the list of emitted values // from EmitKey Points map[string][]float32 // Counters maps the string key to a sum of the counter // values Counters map[string]SampledValue // Samples maps the key to an AggregateSample, // which has the rolled up view of a sample Samples map[string]SampledValue // done is closed when this interval has ended, and a new IntervalMetrics // has been created to receive any future metrics. done chan struct{} } // NewIntervalMetrics creates a new IntervalMetrics for a given interval func NewIntervalMetrics(intv time.Time) IntervalMetrics { return &IntervalMetrics{ Interval: intv, Gauges: make(map[string]GaugeValue), Points: make(map[string][]float32), Counters: make(map[string]SampledValue), Samples: make(map[string]SampledValue), done: make(chan struct{}), } } // AggregateSample is used to hold aggregate metrics // about a sample type AggregateSample struct { Count int // The count of emitted pairs Rate float64 // The values rate per time unit (usually 1 second) Sum float64 // The sum of values SumSq float64 `json:"-"` // The sum of squared values Min float64 // Minimum value Max float64 // Maximum value LastUpdated time.Time `json:"-"` // When value was last updated } // Computes a Stddev of the values func (a AggregateSample) Stddev() float64 { num := (float64(a.Count) a.SumSq) - math.Pow(a.Sum, 2) div := float64(a.Count * (a.Count - 1)) if div == 0 { return 0 } return math.Sqrt(num / div) } // Computes a mean of the values func (a AggregateSample) Mean() float64 { if a.Count == 0 { return 0 } return a.Sum / float64(a.Count) } // Ingest is used to update a sample func (a AggregateSample) Ingest(v float64, rateDenom float64) { a.Count++ a.Sum += v a.SumSq += (v * v) if v < a.Min \|\| a.Count == 1 { a.Min = v } if v > a.Max \|\| a.Count == 1 { a.Max = v } a.Rate = float64(a.Sum) / rateDenom a.LastUpdated = time.Now() } func (a AggregateSample) String() string { if a.Count == 0 { return "Count: 0" } else if a.Stddev() == 0 { return fmt.Sprintf("Count: %d Sum: %0.3f LastUpdated: %s", a.Count, a.Sum, a.LastUpdated) } else { return fmt.Sprintf("Count: %d Min: %0.3f Mean: %0.3f Max: %0.3f Stddev: %0.3f Sum: %0.3f LastUpdated: %s", a.Count, a.Min, a.Mean(), a.Max, a.Stddev(), a.Sum, a.LastUpdated) } } // NewInmemSinkFromURL creates an InmemSink from a URL. It is used // (and tested) from NewMetricSinkFromURL. func NewInmemSinkFromURL(u url.URL) (MetricSink, error) { params := u.Query() interval, err := time.ParseDuration(params.Get("interval")) if err != nil { return nil, fmt.Errorf("Bad 'interval' param: %s", err) } retain, err := time.ParseDuration(params.Get("retain")) if err != nil { return nil, fmt.Errorf("Bad 'retain' param: %s", err) } return NewInmemSink(interval, retain), nil } // NewInmemSink is used to construct a new in-memory sink. // Uses an aggregation interval and maximum retention period. func NewInmemSink(interval, retain time.Duration) InmemSink { rateTimeUnit := time.Second i := &InmemSink{ interval: interval, retain: retain, maxIntervals: int(retain / interval), rateDenom: float64(interval.Nanoseconds()) / float64(rateTimeUnit.Nanoseconds()), } i.intervals = make([]IntervalMetrics, 0, i.maxIntervals) return i } func (i InmemSink) SetGauge(key []string, val float32) { i.SetGaugeWithLabels(key, val, nil) } func (i InmemSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { k, name := i.flattenKeyLabels(key, labels) intv := i.getInterval() intv.Lock() defer intv.Unlock() intv.Gauges[k] = GaugeValue{Name: name, Value: val, Labels: labels} } func (i InmemSink) EmitKey(key []string, val float32) { k := i.flattenKey(key) intv := i.getInterval() intv.Lock() defer intv.Unlock() vals := intv.Points[k] intv.Points[k] = append(vals, val) } func (i InmemSink) IncrCounter(key []string, val float32) { i.IncrCounterWithLabels(key, val, nil) } func (i InmemSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { k, name := i.flattenKeyLabels(key, labels) intv := i.getInterval() intv.Lock() defer intv.Unlock() agg, ok := intv.Counters[k] if !ok { agg = SampledValue{ Name: name, AggregateSample: &AggregateSample{}, Labels: labels, } intv.Counters[k] = agg } agg.Ingest(float64(val), i.rateDenom) } func (i InmemSink) AddSample(key []string, val float32) { i.AddSampleWithLabels(key, val, nil) } func (i InmemSink) AddSampleWithLabels(key []string, val float32, labels []Label) { k, name := i.flattenKeyLabels(key, labels) intv := i.getInterval() intv.Lock() defer intv.Unlock() agg, ok := intv.Samples[k] if !ok { agg = SampledValue{ Name: name, AggregateSample: &AggregateSample{}, Labels: labels, } intv.Samples[k] = agg } agg.Ingest(float64(val), i.rateDenom) } // Data is used to retrieve all the aggregated metrics // Intervals may be in use, and a read lock should be acquired func (i InmemSink) Data() []IntervalMetrics { // Get the current interval, forces creation i.getInterval() i.intervalLock.RLock() defer i.intervalLock.RUnlock() n := len(i.intervals) intervals := make([]IntervalMetrics, n) copy(intervals[:n-1], i.intervals[:n-1]) current := i.intervals[n-1] // make its own copy for current interval intervals[n-1] = &IntervalMetrics{} copyCurrent := intervals[n-1] current.RLock() copyCurrent = current // RWMutex is not safe to copy, so create a new instance on the copy copyCurrent.RWMutex = sync.RWMutex{} copyCurrent.Gauges = make(map[string]GaugeValue, len(current.Gauges)) for k, v := range current.Gauges { copyCurrent.Gauges[k] = v } // saved values will be not change, just copy its link copyCurrent.Points = make(map[string][]float32, len(current.Points)) for k, v := range current.Points { copyCurrent.Points[k] = v } copyCurrent.Counters = make(map[string]SampledValue, len(current.Counters)) for k, v := range current.Counters { copyCurrent.Counters[k] = v.deepCopy() } copyCurrent.Samples = make(map[string]SampledValue, len(current.Samples)) for k, v := range current.Samples { copyCurrent.Samples[k] = v.deepCopy() } current.RUnlock() return intervals } // getInterval returns the current interval. A new interval is created if no // previous interval exists, or if the current time is beyond the window for the // current interval. func (i InmemSink) getInterval() IntervalMetrics { intv := time.Now().Truncate(i.interval) // Attempt to return the existing interval first, because it only requires // a read lock. i.intervalLock.RLock() n := len(i.intervals) if n > 0 && i.intervals[n-1].Interval == intv { defer i.intervalLock.RUnlock() return i.intervals[n-1] } i.intervalLock.RUnlock() i.intervalLock.Lock() defer i.intervalLock.Unlock() // Re-check for an existing interval now that the lock is re-acquired. n = len(i.intervals) if n > 0 && i.intervals[n-1].Interval == intv { return i.intervals[n-1] } current := NewIntervalMetrics(intv) i.intervals = append(i.intervals, current) if n > 0 { close(i.intervals[n-1].done) } n++ // Prune old intervals if the count exceeds the max. if n >= i.maxIntervals { copy(i.intervals[0:], i.intervals[n-i.maxIntervals:]) i.intervals = i.intervals[:i.maxIntervals] } return current } // Flattens the key for formatting, removes spaces func (i InmemSink) flattenKey(parts []string) string { buf := &bytes.Buffer{} joined := strings.Join(parts, ".") spaceReplacer.WriteString(buf, joined) return buf.String() } // Flattens the key for formatting along with its labels, removes spaces func (i InmemSink) flattenKeyLabels(parts []string, labels []Label) (string, string) { key := i.flattenKey(parts) buf := bytes.NewBufferString(key) for _, label := range labels { spaceReplacer.WriteString(buf, fmt.Sprintf(";%s=%s", label.Name, label.Value)) } return buf.String(), key }	8.91 KB	2025-05-25 12:27
📄 inmem_endpoint.go package metrics import ( "context" "fmt" "net/http" "sort" "time" ) // MetricsSummary holds a roll-up of metrics info for a given interval type MetricsSummary struct { Timestamp string Gauges []GaugeValue Points []PointValue Counters []SampledValue Samples []SampledValue } type GaugeValue struct { Name string Hash string `json:"-"` Value float32 Labels []Label `json:"-"` DisplayLabels map[string]string `json:"Labels"` } type PointValue struct { Name string Points []float32 } type SampledValue struct { Name string Hash string `json:"-"` AggregateSample Mean float64 Stddev float64 Labels []Label `json:"-"` DisplayLabels map[string]string `json:"Labels"` } // deepCopy allocates a new instance of AggregateSample func (source SampledValue) deepCopy() SampledValue { dest := source if source.AggregateSample != nil { dest.AggregateSample = &AggregateSample{} dest.AggregateSample = source.AggregateSample } return dest } // DisplayMetrics returns a summary of the metrics from the most recent finished interval. func (i InmemSink) DisplayMetrics(resp http.ResponseWriter, req http.Request) (interface{}, error) { data := i.Data() var interval IntervalMetrics n := len(data) switch { case n == 0: return nil, fmt.Errorf("no metric intervals have been initialized yet") case n == 1: // Show the current interval if it's all we have interval = data[0] default: // Show the most recent finished interval if we have one interval = data[n-2] } return newMetricSummaryFromInterval(interval), nil } func newMetricSummaryFromInterval(interval IntervalMetrics) MetricsSummary { interval.RLock() defer interval.RUnlock() summary := MetricsSummary{ Timestamp: interval.Interval.Round(time.Second).UTC().String(), Gauges: make([]GaugeValue, 0, len(interval.Gauges)), Points: make([]PointValue, 0, len(interval.Points)), } // Format and sort the output of each metric type, so it gets displayed in a // deterministic order. for name, points := range interval.Points { summary.Points = append(summary.Points, PointValue{name, points}) } sort.Slice(summary.Points, func(i, j int) bool { return summary.Points[i].Name < summary.Points[j].Name }) for hash, value := range interval.Gauges { value.Hash = hash value.DisplayLabels = make(map[string]string) for _, label := range value.Labels { value.DisplayLabels[label.Name] = label.Value } value.Labels = nil summary.Gauges = append(summary.Gauges, value) } sort.Slice(summary.Gauges, func(i, j int) bool { return summary.Gauges[i].Hash < summary.Gauges[j].Hash }) summary.Counters = formatSamples(interval.Counters) summary.Samples = formatSamples(interval.Samples) return summary } func formatSamples(source map[string]SampledValue) []SampledValue { output := make([]SampledValue, 0, len(source)) for hash, sample := range source { displayLabels := make(map[string]string) for _, label := range sample.Labels { displayLabels[label.Name] = label.Value } output = append(output, SampledValue{ Name: sample.Name, Hash: hash, AggregateSample: sample.AggregateSample, Mean: sample.AggregateSample.Mean(), Stddev: sample.AggregateSample.Stddev(), DisplayLabels: displayLabels, }) } sort.Slice(output, func(i, j int) bool { return output[i].Hash < output[j].Hash }) return output } type Encoder interface { Encode(interface{}) error } // Stream writes metrics using encoder.Encode each time an interval ends. Runs // until the request context is cancelled, or the encoder returns an error. // The caller is responsible for logging any errors from encoder. func (i InmemSink) Stream(ctx context.Context, encoder Encoder) { interval := i.getInterval() for { select { case <-interval.done: summary := newMetricSummaryFromInterval(interval) if err := encoder.Encode(summary); err != nil { return } // update interval to the next one interval = i.getInterval() case <-ctx.Done(): return } } }	4.02 KB	2025-05-25 12:27
📄 inmem_endpoint_test.go package metrics import ( "context" "encoding/json" "fmt" "net/http" "net/http/httptest" "testing" "time" "github.com/pascaldekloe/goe/verify" ) func TestDisplayMetrics(t testing.T) { interval := 10 time.Millisecond inm := NewInmemSink(interval, 50time.Millisecond) // Add data points inm.SetGauge([]string{"foo", "bar"}, 42) inm.SetGaugeWithLabels([]string{"foo", "bar"}, 23, []Label{{"a", "b"}}) inm.EmitKey([]string{"foo", "bar"}, 42) inm.IncrCounter([]string{"foo", "bar"}, 20) inm.IncrCounter([]string{"foo", "bar"}, 22) inm.IncrCounterWithLabels([]string{"foo", "bar"}, 20, []Label{{"a", "b"}}) inm.IncrCounterWithLabels([]string{"foo", "bar"}, 40, []Label{{"a", "b"}}) inm.AddSample([]string{"foo", "bar"}, 20) inm.AddSample([]string{"foo", "bar"}, 24) inm.AddSampleWithLabels([]string{"foo", "bar"}, 23, []Label{{"a", "b"}}) inm.AddSampleWithLabels([]string{"foo", "bar"}, 33, []Label{{"a", "b"}}) data := inm.Data() if len(data) != 1 { t.Fatalf("bad: %v", data) } expected := MetricsSummary{ Timestamp: data[0].Interval.Round(time.Second).UTC().String(), Gauges: []GaugeValue{ { Name: "foo.bar", Hash: "foo.bar", Value: float32(42), DisplayLabels: map[string]string{}, }, { Name: "foo.bar", Hash: "foo.bar;a=b", Value: float32(23), DisplayLabels: map[string]string{"a": "b"}, }, }, Points: []PointValue{ { Name: "foo.bar", Points: []float32{42}, }, }, Counters: []SampledValue{ { Name: "foo.bar", Hash: "foo.bar", AggregateSample: &AggregateSample{ Count: 2, Min: 20, Max: 22, Sum: 42, SumSq: 884, Rate: 4200, }, Mean: 21, Stddev: 1.4142135623730951, }, { Name: "foo.bar", Hash: "foo.bar;a=b", AggregateSample: &AggregateSample{ Count: 2, Min: 20, Max: 40, Sum: 60, SumSq: 2000, Rate: 6000, }, Mean: 30, Stddev: 14.142135623730951, DisplayLabels: map[string]string{"a": "b"}, }, }, Samples: []SampledValue{ { Name: "foo.bar", Hash: "foo.bar", AggregateSample: &AggregateSample{ Count: 2, Min: 20, Max: 24, Sum: 44, SumSq: 976, Rate: 4400, }, Mean: 22, Stddev: 2.8284271247461903, }, { Name: "foo.bar", Hash: "foo.bar;a=b", AggregateSample: &AggregateSample{ Count: 2, Min: 23, Max: 33, Sum: 56, SumSq: 1618, Rate: 5600, }, Mean: 28, Stddev: 7.0710678118654755, DisplayLabels: map[string]string{"a": "b"}, }, }, } raw, err := inm.DisplayMetrics(nil, nil) if err != nil { t.Fatalf("err: %v", err) } result := raw.(MetricsSummary) // Ignore the LastUpdated field, we don't export that anyway for i, got := range result.Counters { expected.Counters[i].LastUpdated = got.LastUpdated } for i, got := range result.Samples { expected.Samples[i].LastUpdated = got.LastUpdated } verify.Values(t, "all", result, expected) } func TestDisplayMetrics_RaceSetGauge(t testing.T) { interval := 200 * time.Millisecond inm := NewInmemSink(interval, 10interval) result := make(chan float32) go func() { for { time.Sleep(150 time.Millisecond) inm.SetGauge([]string{"foo", "bar"}, float32(42)) } }() go func() { start := time.Now() var summary MetricsSummary // test for twenty intervals for time.Now().Sub(start) < 20interval { time.Sleep(100 time.Millisecond) raw, _ := inm.DisplayMetrics(nil, nil) summary = raw.(MetricsSummary) } // save result for _, g := range summary.Gauges { if g.Name == "foo.bar" { result <- g.Value } } close(result) }() got := <-result verify.Values(t, "all", got, float32(42)) } func TestDisplayMetrics_RaceAddSample(t testing.T) { interval := 200 time.Millisecond inm := NewInmemSink(interval, 10interval) result := make(chan float32) go func() { for { time.Sleep(75 time.Millisecond) inm.AddSample([]string{"foo", "bar"}, float32(0.0)) } }() go func() { start := time.Now() var summary MetricsSummary // test for twenty intervals for time.Now().Sub(start) < 20interval { time.Sleep(100 time.Millisecond) raw, _ := inm.DisplayMetrics(nil, nil) summary = raw.(MetricsSummary) } // save result for _, g := range summary.Gauges { if g.Name == "foo.bar" { result <- g.Value } } close(result) }() got := <-result verify.Values(t, "all", got, float32(0.0)) } func TestDisplayMetrics_RaceIncrCounter(t testing.T) { interval := 200 time.Millisecond inm := NewInmemSink(interval, 10interval) result := make(chan float32) go func() { for { time.Sleep(75 time.Millisecond) inm.IncrCounter([]string{"foo", "bar"}, float32(0.0)) } }() go func() { start := time.Now() var summary MetricsSummary // test for twenty intervals for time.Now().Sub(start) < 20interval { time.Sleep(30 time.Millisecond) raw, _ := inm.DisplayMetrics(nil, nil) summary = raw.(MetricsSummary) } // save result for testing for _, g := range summary.Gauges { if g.Name == "foo.bar" { result <- g.Value } } close(result) }() got := <-result verify.Values(t, "all", got, float32(0.0)) } func TestDisplayMetrics_RaceMetricsSetGauge(t testing.T) { interval := 200 time.Millisecond inm := NewInmemSink(interval, 10interval) met := &Metrics{Config: Config{FilterDefault: true}, sink: inm} result := make(chan float32) labels := []Label{ {"name1", "value1"}, {"name2", "value2"}, } go func() { for { time.Sleep(75 time.Millisecond) met.SetGaugeWithLabels([]string{"foo", "bar"}, float32(42), labels) } }() go func() { start := time.Now() var summary MetricsSummary // test for twenty intervals for time.Now().Sub(start) < 40interval { time.Sleep(150 time.Millisecond) raw, _ := inm.DisplayMetrics(nil, nil) summary = raw.(MetricsSummary) } // save result for _, g := range summary.Gauges { if g.Name == "foo.bar" { result <- g.Value } } close(result) }() got := <-result verify.Values(t, "all", got, float32(42)) } func TestInmemSink_Stream(t testing.T) { interval := 10 time.Millisecond total := 50 * time.Millisecond inm := NewInmemSink(interval, total) ctx, cancel := context.WithTimeout(context.Background(), total2) defer cancel() chDone := make(chan struct{}) go func() { for i := float32(0); ctx.Err() == nil; i++ { inm.SetGaugeWithLabels([]string{"gauge", "foo"}, 20+i, []Label{{"a", "b"}}) inm.EmitKey([]string{"key", "foo"}, 30+i) inm.IncrCounterWithLabels([]string{"counter", "bar"}, 40+i, []Label{{"a", "b"}}) inm.IncrCounterWithLabels([]string{"counter", "bar"}, 50+i, []Label{{"a", "b"}}) inm.AddSampleWithLabels([]string{"sample", "bar"}, 60+i, []Label{{"a", "b"}}) inm.AddSampleWithLabels([]string{"sample", "bar"}, 70+i, []Label{{"a", "b"}}) time.Sleep(interval / 3) } close(chDone) }() resp := httptest.NewRecorder() enc := encoder{ encoder: json.NewEncoder(resp), flusher: resp, } inm.Stream(ctx, enc) <-chDone decoder := json.NewDecoder(resp.Body) var prevGaugeValue float32 for i := 0; i < 8; i++ { var summary MetricsSummary if err := decoder.Decode(&summary); err != nil { t.Fatalf("expected no error while decoding response %d, got %v", i, err) } if count := len(summary.Gauges); count != 1 { t.Fatalf("expected at least one gauge in response %d, got %v", i, count) } value := summary.Gauges[0].Value // The upper bound of the gauge value is not known, but we can expect it // to be less than 50 because it increments by 3 every interval and we run // for ~10 intervals. if value < 20 \|\| value > 50 { t.Fatalf("expected interval %d guage value between 20 and 50, got %v", i, value) } if value <= prevGaugeValue { t.Fatalf("expected interval %d guage value to be greater than previous, %v == %v", i, value, prevGaugeValue) } prevGaugeValue = value } } type encoder struct { flusher http.Flusher encoder json.Encoder } func (e encoder) Encode(metrics interface{}) error { if err := e.encoder.Encode(metrics); err != nil { fmt.Println("failed to encode metrics summary", "error", err) return err } e.flusher.Flush() return nil }	8.21 KB	2025-05-25 12:27
📄 inmem_signal.go package metrics import ( "bytes" "fmt" "io" "os" "os/signal" "strings" "sync" "syscall" ) // InmemSignal is used to listen for a given signal, and when received, // to dump the current metrics from the InmemSink to an io.Writer type InmemSignal struct { signal syscall.Signal inm InmemSink w io.Writer sigCh chan os.Signal stop bool stopCh chan struct{} stopLock sync.Mutex } // NewInmemSignal creates a new InmemSignal which listens for a given signal, // and dumps the current metrics out to a writer func NewInmemSignal(inmem InmemSink, sig syscall.Signal, w io.Writer) InmemSignal { i := &InmemSignal{ signal: sig, inm: inmem, w: w, sigCh: make(chan os.Signal, 1), stopCh: make(chan struct{}), } signal.Notify(i.sigCh, sig) go i.run() return i } // DefaultInmemSignal returns a new InmemSignal that responds to SIGUSR1 // and writes output to stderr. Windows uses SIGBREAK func DefaultInmemSignal(inmem InmemSink) InmemSignal { return NewInmemSignal(inmem, DefaultSignal, os.Stderr) } // Stop is used to stop the InmemSignal from listening func (i InmemSignal) Stop() { i.stopLock.Lock() defer i.stopLock.Unlock() if i.stop { return } i.stop = true close(i.stopCh) signal.Stop(i.sigCh) } // run is a long running routine that handles signals func (i InmemSignal) run() { for { select { case <-i.sigCh: i.dumpStats() case <-i.stopCh: return } } } // dumpStats is used to dump the data to output writer func (i InmemSignal) dumpStats() { buf := bytes.NewBuffer(nil) data := i.inm.Data() // Skip the last period which is still being aggregated for j := 0; j < len(data)-1; j++ { intv := data[j] intv.RLock() for _, val := range intv.Gauges { name := i.flattenLabels(val.Name, val.Labels) fmt.Fprintf(buf, "[%v][G] '%s': %0.3f\n", intv.Interval, name, val.Value) } for name, vals := range intv.Points { for _, val := range vals { fmt.Fprintf(buf, "[%v][P] '%s': %0.3f\n", intv.Interval, name, val) } } for _, agg := range intv.Counters { name := i.flattenLabels(agg.Name, agg.Labels) fmt.Fprintf(buf, "[%v][C] '%s': %s\n", intv.Interval, name, agg.AggregateSample) } for _, agg := range intv.Samples { name := i.flattenLabels(agg.Name, agg.Labels) fmt.Fprintf(buf, "[%v][S] '%s': %s\n", intv.Interval, name, agg.AggregateSample) } intv.RUnlock() } // Write out the bytes i.w.Write(buf.Bytes()) } // Flattens the key for formatting along with its labels, removes spaces func (i *InmemSignal) flattenLabels(name string, labels []Label) string { buf := bytes.NewBufferString(name) replacer := strings.NewReplacer(" ", "_", ":", "_") for _, label := range labels { replacer.WriteString(buf, ".") replacer.WriteString(buf, label.Value) } return buf.String() }	2.76 KB	2025-05-25 12:27
📄 inmem_signal_test.go package metrics import ( "bytes" "os" "strings" "sync" "syscall" "testing" "time" ) func TestInmemSignal(t testing.T) { buf := newBuffer() inm := NewInmemSink(10time.Millisecond, 50time.Millisecond) sig := NewInmemSignal(inm, syscall.SIGUSR1, buf) defer sig.Stop() inm.SetGauge([]string{"foo"}, 42) inm.EmitKey([]string{"bar"}, 42) inm.IncrCounter([]string{"baz"}, 42) inm.AddSample([]string{"wow"}, 42) inm.SetGaugeWithLabels([]string{"asdf"}, 42, []Label{{"a", "b"}}) inm.IncrCounterWithLabels([]string{"qwer"}, 42, []Label{{"a", "b"}}) inm.AddSampleWithLabels([]string{"zxcv"}, 42, []Label{{"a", "b"}}) // Wait for period to end time.Sleep(15 time.Millisecond) // Send signal! syscall.Kill(os.Getpid(), syscall.SIGUSR1) // Wait for flush time.Sleep(10 * time.Millisecond) // Check the output out := buf.String() if !strings.Contains(out, "[G] 'foo': 42") { t.Fatalf("bad: %v", out) } if !strings.Contains(out, "[P] 'bar': 42") { t.Fatalf("bad: %v", out) } if !strings.Contains(out, "[C] 'baz': Count: 1 Sum: 42") { t.Fatalf("bad: %v", out) } if !strings.Contains(out, "[S] 'wow': Count: 1 Sum: 42") { t.Fatalf("bad: %v", out) } if !strings.Contains(out, "[G] 'asdf.b': 42") { t.Fatalf("bad: %v", out) } if !strings.Contains(out, "[C] 'qwer.b': Count: 1 Sum: 42") { t.Fatalf("bad: %v", out) } if !strings.Contains(out, "[S] 'zxcv.b': Count: 1 Sum: 42") { t.Fatalf("bad: %v", out) } } func newBuffer() syncBuffer { return &syncBuffer{buf: bytes.NewBuffer(nil)} } type syncBuffer struct { buf bytes.Buffer lock sync.Mutex } func (s syncBuffer) Write(p []byte) (int, error) { s.lock.Lock() defer s.lock.Unlock() return s.buf.Write(p) } func (s syncBuffer) String() string { s.lock.Lock() defer s.lock.Unlock() return s.buf.String() }	1.78 KB	2025-05-25 12:27
📄 inmem_test.go package metrics import ( "math" "net/url" "strings" "testing" "time" ) func TestInmemSink(t testing.T) { inm := NewInmemSink(10time.Millisecond, 50time.Millisecond) data := inm.Data() if len(data) != 1 { t.Fatalf("bad: %v", data) } // Add data points inm.SetGauge([]string{"foo", "bar"}, 42) inm.SetGaugeWithLabels([]string{"foo", "bar"}, 23, []Label{{"a", "b"}}) inm.EmitKey([]string{"foo", "bar"}, 42) inm.IncrCounter([]string{"foo", "bar"}, 20) inm.IncrCounter([]string{"foo", "bar"}, 22) inm.IncrCounterWithLabels([]string{"foo", "bar"}, 20, []Label{{"a", "b"}}) inm.IncrCounterWithLabels([]string{"foo", "bar"}, 22, []Label{{"a", "b"}}) inm.AddSample([]string{"foo", "bar"}, 20) inm.AddSample([]string{"foo", "bar"}, 22) inm.AddSampleWithLabels([]string{"foo", "bar"}, 23, []Label{{"a", "b"}}) data = inm.Data() if len(data) != 1 { t.Fatalf("bad: %v", data) } intvM := data[0] intvM.RLock() if time.Now().Sub(intvM.Interval) > 10time.Millisecond { t.Fatalf("interval too old") } if intvM.Gauges["foo.bar"].Value != 42 { t.Fatalf("bad val: %v", intvM.Gauges) } if intvM.Gauges["foo.bar;a=b"].Value != 23 { t.Fatalf("bad val: %v", intvM.Gauges) } if intvM.Points["foo.bar"][0] != 42 { t.Fatalf("bad val: %v", intvM.Points) } for _, agg := range []SampledValue{intvM.Counters["foo.bar"], intvM.Counters["foo.bar;a=b"]} { if agg.Count != 2 { t.Fatalf("bad val: %v", agg) } if agg.Rate != 4200 { t.Fatalf("bad val: %v", agg.Rate) } if agg.Sum != 42 { t.Fatalf("bad val: %v", agg) } if agg.SumSq != 884 { t.Fatalf("bad val: %v", agg) } if agg.Min != 20 { t.Fatalf("bad val: %v", agg) } if agg.Max != 22 { t.Fatalf("bad val: %v", agg) } if agg.AggregateSample.Mean() != 21 { t.Fatalf("bad val: %v", agg) } if agg.AggregateSample.Stddev() != math.Sqrt(2) { t.Fatalf("bad val: %v", agg) } if agg.LastUpdated.IsZero() { t.Fatalf("agg.LastUpdated is not set: %v", agg) } diff := time.Now().Sub(agg.LastUpdated).Seconds() if diff > 1 { t.Fatalf("time diff too great: %f", diff) } } if _, ok := intvM.Samples["foo.bar"]; !ok { t.Fatalf("missing sample") } if _, ok := intvM.Samples["foo.bar;a=b"]; !ok { t.Fatalf("missing sample") } intvM.RUnlock() for i := 1; i < 10; i++ { time.Sleep(10 * time.Millisecond) inm.SetGauge([]string{"foo", "bar"}, 42) data = inm.Data() if len(data) != min(i+1, 5) { t.Fatalf("bad: %v", data) } } // Should not exceed 5 intervals! time.Sleep(10 * time.Millisecond) inm.SetGauge([]string{"foo", "bar"}, 42) data = inm.Data() if len(data) != 5 { t.Fatalf("bad: %v", data) } } func TestNewInmemSinkFromURL(t testing.T) { for _, tc := range []struct { desc string input string expectErr string expectInterval time.Duration expectRetain time.Duration }{ { desc: "interval and duration are set via query params", input: "inmem://?interval=11s&retain=22s", expectInterval: duration(t, "11s"), expectRetain: duration(t, "22s"), }, { desc: "interval is required", input: "inmem://?retain=22s", expectErr: "Bad 'interval' param", }, { desc: "interval must be a duration", input: "inmem://?retain=30s&interval=HIYA", expectErr: "Bad 'interval' param", }, { desc: "retain is required", input: "inmem://?interval=30s", expectErr: "Bad 'retain' param", }, { desc: "retain must be a valid duration", input: "inmem://?interval=30s&retain=HELLO", expectErr: "Bad 'retain' param", }, } { t.Run(tc.desc, func(t testing.T) { u, err := url.Parse(tc.input) if err != nil { t.Fatalf("error parsing URL: %s", err) } ms, err := NewInmemSinkFromURL(u) if tc.expectErr != "" { if !strings.Contains(err.Error(), tc.expectErr) { t.Fatalf("expected err: %q, to contain: %q", err, tc.expectErr) } } else { if err != nil { t.Fatalf("unexpected err: %s", err) } is := ms.(InmemSink) if is.interval != tc.expectInterval { t.Fatalf("expected interval %s, got: %s", tc.expectInterval, is.interval) } if is.retain != tc.expectRetain { t.Fatalf("expected retain %s, got: %s", tc.expectRetain, is.retain) } } }) } } func min(a, b int) int { if a < b { return a } return b } func duration(t testing.T, s string) time.Duration { dur, err := time.ParseDuration(s) if err != nil { t.Fatalf("error parsing duration: %s", err) } return dur }	4.45 KB	2025-05-25 12:27
📄 metrics.go package metrics import ( "runtime" "strings" "time" "github.com/hashicorp/go-immutable-radix" ) type Label struct { Name string Value string } func (m Metrics) SetGauge(key []string, val float32) { m.SetGaugeWithLabels(key, val, nil) } func (m Metrics) SetGaugeWithLabels(key []string, val float32, labels []Label) { if m.HostName != "" { if m.EnableHostnameLabel { labels = append(labels, Label{"host", m.HostName}) } else if m.EnableHostname { key = insert(0, m.HostName, key) } } if m.EnableTypePrefix { key = insert(0, "gauge", key) } if m.ServiceName != "" { if m.EnableServiceLabel { labels = append(labels, Label{"service", m.ServiceName}) } else { key = insert(0, m.ServiceName, key) } } allowed, labelsFiltered := m.allowMetric(key, labels) if !allowed { return } m.sink.SetGaugeWithLabels(key, val, labelsFiltered) } func (m Metrics) EmitKey(key []string, val float32) { if m.EnableTypePrefix { key = insert(0, "kv", key) } if m.ServiceName != "" { key = insert(0, m.ServiceName, key) } allowed, _ := m.allowMetric(key, nil) if !allowed { return } m.sink.EmitKey(key, val) } func (m Metrics) IncrCounter(key []string, val float32) { m.IncrCounterWithLabels(key, val, nil) } func (m Metrics) IncrCounterWithLabels(key []string, val float32, labels []Label) { if m.HostName != "" && m.EnableHostnameLabel { labels = append(labels, Label{"host", m.HostName}) } if m.EnableTypePrefix { key = insert(0, "counter", key) } if m.ServiceName != "" { if m.EnableServiceLabel { labels = append(labels, Label{"service", m.ServiceName}) } else { key = insert(0, m.ServiceName, key) } } allowed, labelsFiltered := m.allowMetric(key, labels) if !allowed { return } m.sink.IncrCounterWithLabels(key, val, labelsFiltered) } func (m Metrics) AddSample(key []string, val float32) { m.AddSampleWithLabels(key, val, nil) } func (m Metrics) AddSampleWithLabels(key []string, val float32, labels []Label) { if m.HostName != "" && m.EnableHostnameLabel { labels = append(labels, Label{"host", m.HostName}) } if m.EnableTypePrefix { key = insert(0, "sample", key) } if m.ServiceName != "" { if m.EnableServiceLabel { labels = append(labels, Label{"service", m.ServiceName}) } else { key = insert(0, m.ServiceName, key) } } allowed, labelsFiltered := m.allowMetric(key, labels) if !allowed { return } m.sink.AddSampleWithLabels(key, val, labelsFiltered) } func (m Metrics) MeasureSince(key []string, start time.Time) { m.MeasureSinceWithLabels(key, start, nil) } func (m Metrics) MeasureSinceWithLabels(key []string, start time.Time, labels []Label) { if m.HostName != "" && m.EnableHostnameLabel { labels = append(labels, Label{"host", m.HostName}) } if m.EnableTypePrefix { key = insert(0, "timer", key) } if m.ServiceName != "" { if m.EnableServiceLabel { labels = append(labels, Label{"service", m.ServiceName}) } else { key = insert(0, m.ServiceName, key) } } allowed, labelsFiltered := m.allowMetric(key, labels) if !allowed { return } now := time.Now() elapsed := now.Sub(start) msec := float32(elapsed.Nanoseconds()) / float32(m.TimerGranularity) m.sink.AddSampleWithLabels(key, msec, labelsFiltered) } // UpdateFilter overwrites the existing filter with the given rules. func (m Metrics) UpdateFilter(allow, block []string) { m.UpdateFilterAndLabels(allow, block, m.AllowedLabels, m.BlockedLabels) } // UpdateFilterAndLabels overwrites the existing filter with the given rules. func (m Metrics) UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels []string) { m.filterLock.Lock() defer m.filterLock.Unlock() m.AllowedPrefixes = allow m.BlockedPrefixes = block if allowedLabels == nil { // Having a white list means we take only elements from it m.allowedLabels = nil } else { m.allowedLabels = make(map[string]bool) for _, v := range allowedLabels { m.allowedLabels[v] = true } } m.blockedLabels = make(map[string]bool) for _, v := range blockedLabels { m.blockedLabels[v] = true } m.AllowedLabels = allowedLabels m.BlockedLabels = blockedLabels m.filter = iradix.New() for _, prefix := range m.AllowedPrefixes { m.filter, _, _ = m.filter.Insert([]byte(prefix), true) } for _, prefix := range m.BlockedPrefixes { m.filter, _, _ = m.filter.Insert([]byte(prefix), false) } } // labelIsAllowed return true if a should be included in metric // the caller should lock m.filterLock while calling this method func (m Metrics) labelIsAllowed(label Label) bool { labelName := (label).Name if m.blockedLabels != nil { _, ok := m.blockedLabels[labelName] if ok { // If present, let's remove this label return false } } if m.allowedLabels != nil { _, ok := m.allowedLabels[labelName] return ok } // Allow by default return true } // filterLabels return only allowed labels // the caller should lock m.filterLock while calling this method func (m Metrics) filterLabels(labels []Label) []Label { if labels == nil { return nil } toReturn := []Label{} for _, label := range labels { if m.labelIsAllowed(&label) { toReturn = append(toReturn, label) } } return toReturn } // Returns whether the metric should be allowed based on configured prefix filters // Also return the applicable labels func (m Metrics) allowMetric(key []string, labels []Label) (bool, []Label) { m.filterLock.RLock() defer m.filterLock.RUnlock() if m.filter == nil \|\| m.filter.Len() == 0 { return m.Config.FilterDefault, m.filterLabels(labels) } _, allowed, ok := m.filter.Root().LongestPrefix([]byte(strings.Join(key, "."))) if !ok { return m.Config.FilterDefault, m.filterLabels(labels) } return allowed.(bool), m.filterLabels(labels) } // Periodically collects runtime stats to publish func (m Metrics) collectStats() { for { time.Sleep(m.ProfileInterval) m.EmitRuntimeStats() } } // Emits various runtime statsitics func (m Metrics) EmitRuntimeStats() { // Export number of Goroutines numRoutines := runtime.NumGoroutine() m.SetGauge([]string{"runtime", "num_goroutines"}, float32(numRoutines)) // Export memory stats var stats runtime.MemStats runtime.ReadMemStats(&stats) m.SetGauge([]string{"runtime", "alloc_bytes"}, float32(stats.Alloc)) m.SetGauge([]string{"runtime", "sys_bytes"}, float32(stats.Sys)) m.SetGauge([]string{"runtime", "malloc_count"}, float32(stats.Mallocs)) m.SetGauge([]string{"runtime", "free_count"}, float32(stats.Frees)) m.SetGauge([]string{"runtime", "heap_objects"}, float32(stats.HeapObjects)) m.SetGauge([]string{"runtime", "total_gc_pause_ns"}, float32(stats.PauseTotalNs)) m.SetGauge([]string{"runtime", "total_gc_runs"}, float32(stats.NumGC)) // Export info about the last few GC runs num := stats.NumGC // Handle wrap around if num < m.lastNumGC { m.lastNumGC = 0 } // Ensure we don't scan more than 256 if num-m.lastNumGC >= 256 { m.lastNumGC = num - 255 } for i := m.lastNumGC; i < num; i++ { pause := stats.PauseNs[i%256] m.AddSample([]string{"runtime", "gc_pause_ns"}, float32(pause)) } m.lastNumGC = num } // Creates a new slice with the provided string value as the first element // and the provided slice values as the remaining values. // Ordering of the values in the provided input slice is kept in tact in the output slice. func insert(i int, v string, s []string) []string { // Allocate new slice to avoid modifying the input slice newS := make([]string, len(s)+1) // Copy s[0, i-1] into newS for j := 0; j < i; j++ { newS[j] = s[j] } // Insert provided element at index i newS[i] = v // Copy s[i, len(s)-1] into newS starting at newS[i+1] for j := i; j < len(s); j++ { newS[j+1] = s[j] } return newS }	7.58 KB	2025-05-25 12:27
📄 metrics_test.go package metrics import ( "reflect" "runtime" "testing" "time" ) func mockMetric() (MockSink, Metrics) { m := &MockSink{} met := &Metrics{Config: Config{FilterDefault: true}, sink: m} return m, met } func TestMetrics_SetGauge(t testing.T) { m, met := mockMetric() met.SetGauge([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() labels := []Label{{"a", "b"}} met.SetGaugeWithLabels([]string{"key"}, float32(1), labels) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } if !reflect.DeepEqual(m.labels[0], labels) { t.Fatalf("") } m, met = mockMetric() met.HostName = "test" met.EnableHostname = true met.SetGauge([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "test" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() met.EnableTypePrefix = true met.SetGauge([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "gauge" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() met.ServiceName = "service" met.SetGauge([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "service" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } } func TestMetrics_EmitKey(t testing.T) { m, met := mockMetric() met.EmitKey([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() met.EnableTypePrefix = true met.EmitKey([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "kv" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() met.ServiceName = "service" met.EmitKey([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "service" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } } func TestMetrics_IncrCounter(t testing.T) { m, met := mockMetric() met.IncrCounter([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() labels := []Label{{"a", "b"}} met.IncrCounterWithLabels([]string{"key"}, float32(1), labels) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } if !reflect.DeepEqual(m.labels[0], labels) { t.Fatalf("") } m, met = mockMetric() met.EnableTypePrefix = true met.IncrCounter([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "counter" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() met.ServiceName = "service" met.IncrCounter([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "service" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } } func TestMetrics_AddSample(t testing.T) { m, met := mockMetric() met.AddSample([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() labels := []Label{{"a", "b"}} met.AddSampleWithLabels([]string{"key"}, float32(1), labels) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } if !reflect.DeepEqual(m.labels[0], labels) { t.Fatalf("") } m, met = mockMetric() met.EnableTypePrefix = true met.AddSample([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "sample" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } m, met = mockMetric() met.ServiceName = "service" met.AddSample([]string{"key"}, float32(1)) if m.getKeys()[0][0] != "service" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] != 1 { t.Fatalf("") } } func TestMetrics_MeasureSince(t testing.T) { m, met := mockMetric() met.TimerGranularity = time.Millisecond n := time.Now() met.MeasureSince([]string{"key"}, n) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] > 0.1 { t.Fatalf("") } m, met = mockMetric() met.TimerGranularity = time.Millisecond labels := []Label{{"a", "b"}} met.MeasureSinceWithLabels([]string{"key"}, n, labels) if m.getKeys()[0][0] != "key" { t.Fatalf("") } if m.vals[0] > 0.1 { t.Fatalf("") } if !reflect.DeepEqual(m.labels[0], labels) { t.Fatalf("") } m, met = mockMetric() met.TimerGranularity = time.Millisecond met.EnableTypePrefix = true met.MeasureSince([]string{"key"}, n) if m.getKeys()[0][0] != "timer" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] > 0.1 { t.Fatalf("") } m, met = mockMetric() met.TimerGranularity = time.Millisecond met.ServiceName = "service" met.MeasureSince([]string{"key"}, n) if m.getKeys()[0][0] != "service" \|\| m.getKeys()[0][1] != "key" { t.Fatalf("") } if m.vals[0] > 0.1 { t.Fatalf("") } } func TestMetrics_EmitRuntimeStats(t testing.T) { runtime.GC() m, met := mockMetric() met.EmitRuntimeStats() if m.getKeys()[0][0] != "runtime" \|\| m.getKeys()[0][1] != "num_goroutines" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[0] <= 1 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[1][0] != "runtime" \|\| m.getKeys()[1][1] != "alloc_bytes" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[1] <= 40000 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[2][0] != "runtime" \|\| m.getKeys()[2][1] != "sys_bytes" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[2] <= 100000 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[3][0] != "runtime" \|\| m.getKeys()[3][1] != "malloc_count" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[3] <= 100 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[4][0] != "runtime" \|\| m.getKeys()[4][1] != "free_count" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[4] <= 100 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[5][0] != "runtime" \|\| m.getKeys()[5][1] != "heap_objects" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[5] <= 100 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[6][0] != "runtime" \|\| m.getKeys()[6][1] != "total_gc_pause_ns" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[6] <= 100 { t.Fatalf("bad val: %v\nkeys: %v", m.vals, m.getKeys()) } if m.getKeys()[7][0] != "runtime" \|\| m.getKeys()[7][1] != "total_gc_runs" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[7] < 1 { t.Fatalf("bad val: %v", m.vals) } if m.getKeys()[8][0] != "runtime" \|\| m.getKeys()[8][1] != "gc_pause_ns" { t.Fatalf("bad key %v", m.getKeys()) } if m.vals[8] <= 1000 { t.Fatalf("bad val: %v", m.vals) } } func TestInsert(t testing.T) { k := []string{"hi", "bob"} exp := []string{"hi", "there", "bob"} out := insert(1, "there", k) if !reflect.DeepEqual(exp, out) { t.Fatalf("bad insert %v %v", exp, out) } } func TestMetrics_Filter_Blacklist(t testing.T) { m := &MockSink{} conf := DefaultConfig("") conf.AllowedPrefixes = []string{"service", "debug.thing"} conf.BlockedPrefixes = []string{"debug"} conf.EnableHostname = false met, err := New(conf, m) if err != nil { t.Fatal(err) } // Allowed by default key := []string{"thing"} met.SetGauge(key, 1) if !reflect.DeepEqual(m.getKeys()[0], key) { t.Fatalf("key doesn't exist %v, %v", m.getKeys()[0], key) } if m.vals[0] != 1 { t.Fatalf("bad val: %v", m.vals[0]) } // Allowed by filter key = []string{"service", "thing"} met.SetGauge(key, 2) if !reflect.DeepEqual(m.getKeys()[1], key) { t.Fatalf("key doesn't exist") } if m.vals[1] != 2 { t.Fatalf("bad val: %v", m.vals[1]) } // Allowed by filter, subtree of a blocked entry key = []string{"debug", "thing"} met.SetGauge(key, 3) if !reflect.DeepEqual(m.getKeys()[2], key) { t.Fatalf("key doesn't exist") } if m.vals[2] != 3 { t.Fatalf("bad val: %v", m.vals[2]) } // Blocked by filter key = []string{"debug", "other-thing"} met.SetGauge(key, 4) if len(m.getKeys()) != 3 { t.Fatalf("key shouldn't exist") } } func HasElem(s interface{}, elem interface{}) bool { arrV := reflect.ValueOf(s) if arrV.Kind() == reflect.Slice { for i := 0; i < arrV.Len(); i++ { if arrV.Index(i).Interface() == elem { return true } } } return false } func TestMetrics_Filter_Whitelist(t testing.T) { m := &MockSink{} conf := DefaultConfig("") conf.AllowedPrefixes = []string{"service", "debug.thing"} conf.BlockedPrefixes = []string{"debug"} conf.FilterDefault = false conf.EnableHostname = false conf.BlockedLabels = []string{"bad_label"} met, err := New(conf, m) if err != nil { t.Fatal(err) } // Blocked by default key := []string{"thing"} met.SetGauge(key, 1) if len(m.getKeys()) != 0 { t.Fatalf("key should not exist") } // Allowed by filter key = []string{"service", "thing"} met.SetGauge(key, 2) if !reflect.DeepEqual(m.getKeys()[0], key) { t.Fatalf("key doesn't exist") } if m.vals[0] != 2 { t.Fatalf("bad val: %v", m.vals[0]) } // Allowed by filter, subtree of a blocked entry key = []string{"debug", "thing"} met.SetGauge(key, 3) if !reflect.DeepEqual(m.getKeys()[1], key) { t.Fatalf("key doesn't exist") } if m.vals[1] != 3 { t.Fatalf("bad val: %v", m.vals[1]) } // Blocked by filter key = []string{"debug", "other-thing"} met.SetGauge(key, 4) if len(m.getKeys()) != 2 { t.Fatalf("key shouldn't exist") } // Test blacklisting of labels key = []string{"debug", "thing"} goodLabel := Label{Name: "good", Value: "should be present"} badLabel := Label{Name: "bad_label", Value: "should not be there"} labels := []Label{badLabel, goodLabel} met.SetGaugeWithLabels(key, 3, labels) if !reflect.DeepEqual(m.getKeys()[1], key) { t.Fatalf("key doesn't exist") } if m.vals[2] != 3 { t.Fatalf("bad val: %v", m.vals[1]) } if HasElem(m.labels[2], badLabel) { t.Fatalf("bad_label should not be present in %v", m.labels[2]) } if !HasElem(m.labels[2], goodLabel) { t.Fatalf("good label is not present in %v", m.labels[2]) } } func TestMetrics_Filter_Labels_Whitelist(t testing.T) { m := &MockSink{} conf := DefaultConfig("") conf.AllowedPrefixes = []string{"service", "debug.thing"} conf.BlockedPrefixes = []string{"debug"} conf.FilterDefault = false conf.EnableHostname = false conf.AllowedLabels = []string{"good_label"} conf.BlockedLabels = []string{"bad_label"} met, err := New(conf, m) if err != nil { t.Fatal(err) } // Blocked by default key := []string{"thing"} key = []string{"debug", "thing"} goodLabel := Label{Name: "good_label", Value: "should be present"} notReallyGoodLabel := Label{Name: "not_really_good_label", Value: "not whitelisted, but not blacklisted"} badLabel := Label{Name: "bad_label", Value: "should not be there"} labels := []Label{badLabel, notReallyGoodLabel, goodLabel} met.SetGaugeWithLabels(key, 1, labels) if HasElem(m.labels[0], badLabel) { t.Fatalf("bad_label should not be present in %v", m.labels[0]) } if HasElem(m.labels[0], notReallyGoodLabel) { t.Fatalf("not_really_good_label should not be present in %v", m.labels[0]) } if !HasElem(m.labels[0], goodLabel) { t.Fatalf("good label is not present in %v", m.labels[0]) } conf.AllowedLabels = nil met.UpdateFilterAndLabels(conf.AllowedPrefixes, conf.BlockedLabels, conf.AllowedLabels, conf.BlockedLabels) met.SetGaugeWithLabels(key, 1, labels) if HasElem(m.labels[1], badLabel) { t.Fatalf("bad_label should not be present in %v", m.labels[1]) } // Since no whitelist, not_really_good_label should be there if !HasElem(m.labels[1], notReallyGoodLabel) { t.Fatalf("not_really_good_label is not present in %v", m.labels[1]) } if !HasElem(m.labels[1], goodLabel) { t.Fatalf("good label is not present in %v", m.labels[1]) } } func TestMetrics_Filter_Labels_ModifyArgs(t *testing.T) { m := &MockSink{} conf := DefaultConfig("") conf.FilterDefault = false conf.EnableHostname = false conf.AllowedLabels = []string{"keep"} conf.BlockedLabels = []string{"delete"} met, err := New(conf, m) if err != nil { t.Fatal(err) } // Blocked by default key := []string{"thing"} key = []string{"debug", "thing"} goodLabel := Label{Name: "keep", Value: "should be kept"} badLabel := Label{Name: "delete", Value: "should be deleted"} argLabels := []Label{badLabel, goodLabel, badLabel, goodLabel, badLabel, goodLabel, badLabel} origLabels := append([]Label{}, argLabels...) met.SetGaugeWithLabels(key, 1, argLabels) if !reflect.DeepEqual(argLabels, origLabels) { t.Fatalf("SetGaugeWithLabels modified the input argument") } }	12.26 KB	2025-05-25 12:27
📁 prometheus	-	2025-05-25 12:27
📄 sink.go package metrics import ( "fmt" "net/url" ) // The MetricSink interface is used to transmit metrics information // to an external system type MetricSink interface { // A Gauge should retain the last value it is set to SetGauge(key []string, val float32) SetGaugeWithLabels(key []string, val float32, labels []Label) // Should emit a Key/Value pair for each call EmitKey(key []string, val float32) // Counters should accumulate values IncrCounter(key []string, val float32) IncrCounterWithLabels(key []string, val float32, labels []Label) // Samples are for timing information, where quantiles are used AddSample(key []string, val float32) AddSampleWithLabels(key []string, val float32, labels []Label) } // BlackholeSink is used to just blackhole messages type BlackholeSink struct{} func (BlackholeSink) SetGauge(key []string, val float32) {} func (BlackholeSink) SetGaugeWithLabels(key []string, val float32, labels []Label) {} func (BlackholeSink) EmitKey(key []string, val float32) {} func (BlackholeSink) IncrCounter(key []string, val float32) {} func (BlackholeSink) IncrCounterWithLabels(key []string, val float32, labels []Label) {} func (BlackholeSink) AddSample(key []string, val float32) {} func (BlackholeSink) AddSampleWithLabels(key []string, val float32, labels []Label) {} // FanoutSink is used to sink to fanout values to multiple sinks type FanoutSink []MetricSink func (fh FanoutSink) SetGauge(key []string, val float32) { fh.SetGaugeWithLabels(key, val, nil) } func (fh FanoutSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { for _, s := range fh { s.SetGaugeWithLabels(key, val, labels) } } func (fh FanoutSink) EmitKey(key []string, val float32) { for _, s := range fh { s.EmitKey(key, val) } } func (fh FanoutSink) IncrCounter(key []string, val float32) { fh.IncrCounterWithLabels(key, val, nil) } func (fh FanoutSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { for _, s := range fh { s.IncrCounterWithLabels(key, val, labels) } } func (fh FanoutSink) AddSample(key []string, val float32) { fh.AddSampleWithLabels(key, val, nil) } func (fh FanoutSink) AddSampleWithLabels(key []string, val float32, labels []Label) { for _, s := range fh { s.AddSampleWithLabels(key, val, labels) } } // sinkURLFactoryFunc is an generic interface around the SinkFromURL() function provided // by each sink type type sinkURLFactoryFunc func(*url.URL) (MetricSink, error) // sinkRegistry supports the generic NewMetricSink function by mapping URL // schemes to metric sink factory functions var sinkRegistry = map[string]sinkURLFactoryFunc{ "statsd": NewStatsdSinkFromURL, "statsite": NewStatsiteSinkFromURL, "inmem": NewInmemSinkFromURL, } // NewMetricSinkFromURL allows a generic URL input to configure any of the // supported sinks. The scheme of the URL identifies the type of the sink, the // and query parameters are used to set options. // // "statsd://" - Initializes a StatsdSink. The host and port are passed through // as the "addr" of the sink // // "statsite://" - Initializes a StatsiteSink. The host and port become the // "addr" of the sink // // "inmem://" - Initializes an InmemSink. The host and port are ignored. The // "interval" and "duration" query parameters must be specified with valid // durations, see NewInmemSink for details. func NewMetricSinkFromURL(urlStr string) (MetricSink, error) { u, err := url.Parse(urlStr) if err != nil { return nil, err } sinkURLFactoryFunc := sinkRegistry[u.Scheme] if sinkURLFactoryFunc == nil { return nil, fmt.Errorf( "cannot create metric sink, unrecognized sink name: %q", u.Scheme) } return sinkURLFactoryFunc(u) }	3.74 KB	2025-05-25 12:27
📄 sink_test.go package metrics import ( "reflect" "strings" "sync" "testing" ) type MockSink struct { lock sync.Mutex keys [][]string vals []float32 labels [][]Label } func (m MockSink) getKeys() [][]string { m.lock.Lock() defer m.lock.Unlock() return m.keys } func (m MockSink) SetGauge(key []string, val float32) { m.SetGaugeWithLabels(key, val, nil) } func (m MockSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { m.lock.Lock() defer m.lock.Unlock() m.keys = append(m.keys, key) m.vals = append(m.vals, val) m.labels = append(m.labels, labels) } func (m MockSink) EmitKey(key []string, val float32) { m.lock.Lock() defer m.lock.Unlock() m.keys = append(m.keys, key) m.vals = append(m.vals, val) m.labels = append(m.labels, nil) } func (m MockSink) IncrCounter(key []string, val float32) { m.IncrCounterWithLabels(key, val, nil) } func (m MockSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { m.lock.Lock() defer m.lock.Unlock() m.keys = append(m.keys, key) m.vals = append(m.vals, val) m.labels = append(m.labels, labels) } func (m MockSink) AddSample(key []string, val float32) { m.AddSampleWithLabels(key, val, nil) } func (m MockSink) AddSampleWithLabels(key []string, val float32, labels []Label) { m.lock.Lock() defer m.lock.Unlock() m.keys = append(m.keys, key) m.vals = append(m.vals, val) m.labels = append(m.labels, labels) } func TestFanoutSink_Gauge(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) fh.SetGauge(k, v) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } } func TestFanoutSink_Gauge_Labels(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) l := []Label{{"a", "b"}} fh.SetGaugeWithLabels(k, v, l) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m1.labels[0], l) { t.Fatalf("labels not equal") } if !reflect.DeepEqual(m2.labels[0], l) { t.Fatalf("labels not equal") } } func TestFanoutSink_Key(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) fh.EmitKey(k, v) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } } func TestFanoutSink_Counter(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) fh.IncrCounter(k, v) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } } func TestFanoutSink_Counter_Labels(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) l := []Label{{"a", "b"}} fh.IncrCounterWithLabels(k, v, l) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m1.labels[0], l) { t.Fatalf("labels not equal") } if !reflect.DeepEqual(m2.labels[0], l) { t.Fatalf("labels not equal") } } func TestFanoutSink_Sample(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) fh.AddSample(k, v) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } } func TestFanoutSink_Sample_Labels(t testing.T) { m1 := &MockSink{} m2 := &MockSink{} fh := &FanoutSink{m1, m2} k := []string{"test"} v := float32(42.0) l := []Label{{"a", "b"}} fh.AddSampleWithLabels(k, v, l) if !reflect.DeepEqual(m1.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m2.keys[0], k) { t.Fatalf("key not equal") } if !reflect.DeepEqual(m1.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m2.vals[0], v) { t.Fatalf("val not equal") } if !reflect.DeepEqual(m1.labels[0], l) { t.Fatalf("labels not equal") } if !reflect.DeepEqual(m2.labels[0], l) { t.Fatalf("labels not equal") } } func TestNewMetricSinkFromURL(t testing.T) { for _, tc := range []struct { desc string input string expect reflect.Type expectErr string }{ { desc: "statsd scheme yields a StatsdSink", input: "statsd://someserver:123", expect: reflect.TypeOf(&StatsdSink{}), }, { desc: "statsite scheme yields a StatsiteSink", input: "statsite://someserver:123", expect: reflect.TypeOf(&StatsiteSink{}), }, { desc: "inmem scheme yields an InmemSink", input: "inmem://?interval=30s&retain=30s", expect: reflect.TypeOf(&InmemSink{}), }, { desc: "unknown scheme yields an error", input: "notasink://whatever", expectErr: "unrecognized sink name: \"notasink\"", }, } { t.Run(tc.desc, func(t *testing.T) { ms, err := NewMetricSinkFromURL(tc.input) if tc.expectErr != "" { if !strings.Contains(err.Error(), tc.expectErr) { t.Fatalf("expected err: %q to contain: %q", err, tc.expectErr) } } else { if err != nil { t.Fatalf("unexpected err: %s", err) } got := reflect.TypeOf(ms) if got != tc.expect { t.Fatalf("expected return type to be %v, got: %v", tc.expect, got) } } }) } }	6.29 KB	2025-05-25 12:27
📄 start.go package metrics import ( "os" "sync" "sync/atomic" "time" iradix "github.com/hashicorp/go-immutable-radix" ) // Config is used to configure metrics settings type Config struct { ServiceName string // Prefixed with keys to separate services HostName string // Hostname to use. If not provided and EnableHostname, it will be os.Hostname EnableHostname bool // Enable prefixing gauge values with hostname EnableHostnameLabel bool // Enable adding hostname to labels EnableServiceLabel bool // Enable adding service to labels EnableRuntimeMetrics bool // Enables profiling of runtime metrics (GC, Goroutines, Memory) EnableTypePrefix bool // Prefixes key with a type ("counter", "gauge", "timer") TimerGranularity time.Duration // Granularity of timers. ProfileInterval time.Duration // Interval to profile runtime metrics AllowedPrefixes []string // A list of metric prefixes to allow, with '.' as the separator BlockedPrefixes []string // A list of metric prefixes to block, with '.' as the separator AllowedLabels []string // A list of metric labels to allow, with '.' as the separator BlockedLabels []string // A list of metric labels to block, with '.' as the separator FilterDefault bool // Whether to allow metrics by default } // Metrics represents an instance of a metrics sink that can // be used to emit type Metrics struct { Config lastNumGC uint32 sink MetricSink filter iradix.Tree allowedLabels map[string]bool blockedLabels map[string]bool filterLock sync.RWMutex // Lock filters and allowedLabels/blockedLabels access } // Shared global metrics instance var globalMetrics atomic.Value // Metrics func init() { // Initialize to a blackhole sink to avoid errors globalMetrics.Store(&Metrics{sink: &BlackholeSink{}}) } // Default returns the shared global metrics instance. func Default() Metrics { return globalMetrics.Load().(Metrics) } // DefaultConfig provides a sane default configuration func DefaultConfig(serviceName string) Config { c := &Config{ ServiceName: serviceName, // Use client provided service HostName: "", EnableHostname: true, // Enable hostname prefix EnableRuntimeMetrics: true, // Enable runtime profiling EnableTypePrefix: false, // Disable type prefix TimerGranularity: time.Millisecond, // Timers are in milliseconds ProfileInterval: time.Second, // Poll runtime every second FilterDefault: true, // Don't filter metrics by default } // Try to get the hostname name, _ := os.Hostname() c.HostName = name return c } // New is used to create a new instance of Metrics func New(conf Config, sink MetricSink) (Metrics, error) { met := &Metrics{} met.Config = conf met.sink = sink met.UpdateFilterAndLabels(conf.AllowedPrefixes, conf.BlockedPrefixes, conf.AllowedLabels, conf.BlockedLabels) // Start the runtime collector if conf.EnableRuntimeMetrics { go met.collectStats() } return met, nil } // NewGlobal is the same as New, but it assigns the metrics object to be // used globally as well as returning it. func NewGlobal(conf Config, sink MetricSink) (Metrics, error) { metrics, err := New(conf, sink) if err == nil { globalMetrics.Store(metrics) } return metrics, err } // Proxy all the methods to the globalMetrics instance func SetGauge(key []string, val float32) { globalMetrics.Load().(Metrics).SetGauge(key, val) } func SetGaugeWithLabels(key []string, val float32, labels []Label) { globalMetrics.Load().(Metrics).SetGaugeWithLabels(key, val, labels) } func EmitKey(key []string, val float32) { globalMetrics.Load().(Metrics).EmitKey(key, val) } func IncrCounter(key []string, val float32) { globalMetrics.Load().(Metrics).IncrCounter(key, val) } func IncrCounterWithLabels(key []string, val float32, labels []Label) { globalMetrics.Load().(Metrics).IncrCounterWithLabels(key, val, labels) } func AddSample(key []string, val float32) { globalMetrics.Load().(Metrics).AddSample(key, val) } func AddSampleWithLabels(key []string, val float32, labels []Label) { globalMetrics.Load().(Metrics).AddSampleWithLabels(key, val, labels) } func MeasureSince(key []string, start time.Time) { globalMetrics.Load().(Metrics).MeasureSince(key, start) } func MeasureSinceWithLabels(key []string, start time.Time, labels []Label) { globalMetrics.Load().(Metrics).MeasureSinceWithLabels(key, start, labels) } func UpdateFilter(allow, block []string) { globalMetrics.Load().(Metrics).UpdateFilter(allow, block) } // UpdateFilterAndLabels set allow/block prefixes of metrics while allowedLabels // and blockedLabels - when not nil - allow filtering of labels in order to // block/allow globally labels (especially useful when having large number of // values for a given label). See README.md for more information about usage. func UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels []string) { globalMetrics.Load().(*Metrics).UpdateFilterAndLabels(allow, block, allowedLabels, blockedLabels) }	5.07 KB	2025-05-25 12:27
📄 start_test.go package metrics import ( "io/ioutil" "log" "reflect" "sync/atomic" "testing" "time" ) func TestDefaultConfig(t testing.T) { conf := DefaultConfig("service") if conf.ServiceName != "service" { t.Fatalf("Bad name") } if conf.HostName == "" { t.Fatalf("missing hostname") } if !conf.EnableHostname \|\| !conf.EnableRuntimeMetrics { t.Fatalf("expect true") } if conf.EnableTypePrefix { t.Fatalf("expect false") } if conf.TimerGranularity != time.Millisecond { t.Fatalf("bad granularity") } if conf.ProfileInterval != time.Second { t.Fatalf("bad interval") } } func Test_GlobalMetrics(t testing.T) { var tests = []struct { desc string key []string val float32 fn func([]string, float32) }{ {"SetGauge", []string{"test"}, 42, SetGauge}, {"EmitKey", []string{"test"}, 42, EmitKey}, {"IncrCounter", []string{"test"}, 42, IncrCounter}, {"AddSample", []string{"test"}, 42, AddSample}, } for _, tt := range tests { t.Run(tt.desc, func(t testing.T) { s := &MockSink{} globalMetrics.Store(&Metrics{Config: Config{FilterDefault: true}, sink: s}) tt.fn(tt.key, tt.val) if got, want := s.keys[0], tt.key; !reflect.DeepEqual(got, want) { t.Fatalf("got key %s want %s", got, want) } if got, want := s.vals[0], tt.val; !reflect.DeepEqual(got, want) { t.Fatalf("got val %v want %v", got, want) } }) } } func Test_GlobalMetrics_Labels(t testing.T) { labels := []Label{{"a", "b"}} var tests = []struct { desc string key []string val float32 fn func([]string, float32, []Label) labels []Label }{ {"SetGaugeWithLabels", []string{"test"}, 42, SetGaugeWithLabels, labels}, {"IncrCounterWithLabels", []string{"test"}, 42, IncrCounterWithLabels, labels}, {"AddSampleWithLabels", []string{"test"}, 42, AddSampleWithLabels, labels}, } for _, tt := range tests { t.Run(tt.desc, func(t testing.T) { s := &MockSink{} globalMetrics.Store(&Metrics{Config: Config{FilterDefault: true}, sink: s}) tt.fn(tt.key, tt.val, tt.labels) if got, want := s.keys[0], tt.key; !reflect.DeepEqual(got, want) { t.Fatalf("got key %s want %s", got, want) } if got, want := s.vals[0], tt.val; !reflect.DeepEqual(got, want) { t.Fatalf("got val %v want %v", got, want) } if got, want := s.labels[0], tt.labels; !reflect.DeepEqual(got, want) { t.Fatalf("got val %s want %s", got, want) } }) } } func Test_GlobalMetrics_DefaultLabels(t testing.T) { config := Config{ HostName: "host1", ServiceName: "redis", EnableHostnameLabel: true, EnableServiceLabel: true, FilterDefault: true, } labels := []Label{ {"host", config.HostName}, {"service", config.ServiceName}, } var tests = []struct { desc string key []string val float32 fn func([]string, float32, []Label) labels []Label }{ {"SetGaugeWithLabels", []string{"test"}, 42, SetGaugeWithLabels, labels}, {"IncrCounterWithLabels", []string{"test"}, 42, IncrCounterWithLabels, labels}, {"AddSampleWithLabels", []string{"test"}, 42, AddSampleWithLabels, labels}, } for _, tt := range tests { t.Run(tt.desc, func(t testing.T) { s := &MockSink{} globalMetrics.Store(&Metrics{Config: config, sink: s}) tt.fn(tt.key, tt.val, nil) if got, want := s.keys[0], tt.key; !reflect.DeepEqual(got, want) { t.Fatalf("got key %s want %s", got, want) } if got, want := s.vals[0], tt.val; !reflect.DeepEqual(got, want) { t.Fatalf("got val %v want %v", got, want) } if got, want := s.labels[0], tt.labels; !reflect.DeepEqual(got, want) { t.Fatalf("got val %s want %s", got, want) } }) } } func Test_GlobalMetrics_MeasureSince(t testing.T) { s := &MockSink{} m := &Metrics{sink: s, Config: Config{TimerGranularity: time.Millisecond, FilterDefault: true}} globalMetrics.Store(m) k := []string{"test"} now := time.Now() MeasureSince(k, now) if !reflect.DeepEqual(s.keys[0], k) { t.Fatalf("key not equal") } if s.vals[0] > 0.1 { t.Fatalf("val too large %v", s.vals[0]) } labels := []Label{{"a", "b"}} MeasureSinceWithLabels(k, now, labels) if got, want := s.keys[1], k; !reflect.DeepEqual(got, want) { t.Fatalf("got key %s want %s", got, want) } if s.vals[1] > 0.1 { t.Fatalf("val too large %v", s.vals[0]) } if got, want := s.labels[1], labels; !reflect.DeepEqual(got, want) { t.Fatalf("got val %s want %s", got, want) } } func Test_GlobalMetrics_UpdateFilter(t testing.T) { globalMetrics.Store(&Metrics{Config: Config{ AllowedPrefixes: []string{"a"}, BlockedPrefixes: []string{"b"}, AllowedLabels: []string{"1"}, BlockedLabels: []string{"2"}, }}) UpdateFilterAndLabels([]string{"c"}, []string{"d"}, []string{"3"}, []string{"4"}) m := globalMetrics.Load().(Metrics) if m.AllowedPrefixes[0] != "c" { t.Fatalf("bad: %v", m.AllowedPrefixes) } if m.BlockedPrefixes[0] != "d" { t.Fatalf("bad: %v", m.BlockedPrefixes) } if m.AllowedLabels[0] != "3" { t.Fatalf("bad: %v", m.AllowedPrefixes) } if m.BlockedLabels[0] != "4" { t.Fatalf("bad: %v", m.AllowedPrefixes) } if _, ok := m.allowedLabels["3"]; !ok { t.Fatalf("bad: %v", m.allowedLabels) } if _, ok := m.blockedLabels["4"]; !ok { t.Fatalf("bad: %v", m.blockedLabels) } } // Benchmark_GlobalMetrics_Direct/direct-8 5000000 278 ns/op // Benchmark_GlobalMetrics_Direct/atomic.Value-8 5000000 235 ns/op func Benchmark_GlobalMetrics_Direct(b testing.B) { log.SetOutput(ioutil.Discard) s := &MockSink{} m := &Metrics{sink: s} var v atomic.Value v.Store(m) k := []string{"test"} b.Run("direct", func(b testing.B) { for i := 0; i < b.N; i++ { m.IncrCounter(k, 1) } }) b.Run("atomic.Value", func(b testing.B) { for i := 0; i < b.N; i++ { v.Load().(Metrics).IncrCounter(k, 1) } }) // do something with m so that the compiler does not optimize this away b.Logf("%d", m.lastNumGC) }	5.78 KB	2025-05-25 12:27
📄 statsd.go package metrics import ( "bytes" "fmt" "log" "net" "net/url" "strings" "time" ) const ( // statsdMaxLen is the maximum size of a packet // to send to statsd statsdMaxLen = 1400 ) // StatsdSink provides a MetricSink that can be used // with a statsite or statsd metrics server. It uses // only UDP packets, while StatsiteSink uses TCP. type StatsdSink struct { addr string metricQueue chan string } // NewStatsdSinkFromURL creates an StatsdSink from a URL. It is used // (and tested) from NewMetricSinkFromURL. func NewStatsdSinkFromURL(u url.URL) (MetricSink, error) { return NewStatsdSink(u.Host) } // NewStatsdSink is used to create a new StatsdSink func NewStatsdSink(addr string) (StatsdSink, error) { s := &StatsdSink{ addr: addr, metricQueue: make(chan string, 4096), } go s.flushMetrics() return s, nil } // Close is used to stop flushing to statsd func (s StatsdSink) Shutdown() { close(s.metricQueue) } func (s StatsdSink) SetGauge(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|g\n", flatKey, val)) } func (s StatsdSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { flatKey := s.flattenKeyLabels(key, labels) s.pushMetric(fmt.Sprintf("%s:%f\|g\n", flatKey, val)) } func (s StatsdSink) EmitKey(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|kv\n", flatKey, val)) } func (s StatsdSink) IncrCounter(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|c\n", flatKey, val)) } func (s StatsdSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { flatKey := s.flattenKeyLabels(key, labels) s.pushMetric(fmt.Sprintf("%s:%f\|c\n", flatKey, val)) } func (s StatsdSink) AddSample(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|ms\n", flatKey, val)) } func (s StatsdSink) AddSampleWithLabels(key []string, val float32, labels []Label) { flatKey := s.flattenKeyLabels(key, labels) s.pushMetric(fmt.Sprintf("%s:%f\|ms\n", flatKey, val)) } // Flattens the key for formatting, removes spaces func (s StatsdSink) flattenKey(parts []string) string { joined := strings.Join(parts, ".") return strings.Map(func(r rune) rune { switch r { case ':': fallthrough case ' ': return '_' default: return r } }, joined) } // Flattens the key along with labels for formatting, removes spaces func (s StatsdSink) flattenKeyLabels(parts []string, labels []Label) string { for _, label := range labels { parts = append(parts, label.Value) } return s.flattenKey(parts) } // Does a non-blocking push to the metrics queue func (s StatsdSink) pushMetric(m string) { select { case s.metricQueue <- m: default: } } // Flushes metrics func (s StatsdSink) flushMetrics() { var sock net.Conn var err error var wait <-chan time.Time ticker := time.NewTicker(flushInterval) defer ticker.Stop() CONNECT: // Create a buffer buf := bytes.NewBuffer(nil) // Attempt to connect sock, err = net.Dial("udp", s.addr) if err != nil { log.Printf("[ERR] Error connecting to statsd! Err: %s", err) goto WAIT } for { select { case metric, ok := <-s.metricQueue: // Get a metric from the queue if !ok { goto QUIT } // Check if this would overflow the packet size if len(metric)+buf.Len() > statsdMaxLen { _, err := sock.Write(buf.Bytes()) buf.Reset() if err != nil { log.Printf("[ERR] Error writing to statsd! Err: %s", err) goto WAIT } } // Append to the buffer buf.WriteString(metric) case <-ticker.C: if buf.Len() == 0 { continue } _, err := sock.Write(buf.Bytes()) buf.Reset() if err != nil { log.Printf("[ERR] Error flushing to statsd! Err: %s", err) goto WAIT } } } WAIT: // Wait for a while wait = time.After(time.Duration(5) * time.Second) for { select { // Dequeue the messages to avoid backlog case _, ok := <-s.metricQueue: if !ok { goto QUIT } case <-wait: goto CONNECT } } QUIT: s.metricQueue = nil }	4.03 KB	2025-05-25 12:27
📄 statsd_test.go package metrics import ( "bufio" "bytes" "net" "net/url" "strings" "testing" "time" ) func TestStatsd_Flatten(t testing.T) { s := &StatsdSink{} flat := s.flattenKey([]string{"a", "b", "c", "d"}) if flat != "a.b.c.d" { t.Fatalf("Bad flat") } } func TestStatsd_PushFullQueue(t testing.T) { q := make(chan string, 1) q <- "full" s := &StatsdSink{metricQueue: q} s.pushMetric("omit") out := <-q if out != "full" { t.Fatalf("bad val %v", out) } select { case v := <-q: t.Fatalf("bad val %v", v) default: } } func TestStatsd_Conn(t testing.T) { addr := "127.0.0.1:7524" done := make(chan bool) go func() { list, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 7524}) if err != nil { panic(err) } defer list.Close() buf := make([]byte, 1500) n, err := list.Read(buf) if err != nil { panic(err) } buf = buf[:n] reader := bufio.NewReader(bytes.NewReader(buf)) line, err := reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "gauge.val:1.000000\|g\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "gauge_labels.val.label:2.000000\|g\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "key.other:3.000000\|kv\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "counter.me:4.000000\|c\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "counter_labels.me.label:5.000000\|c\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "sample.slow_thingy:6.000000\|ms\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "sample_labels.slow_thingy.label:7.000000\|ms\n" { t.Fatalf("bad line %s", line) } done <- true }() s, err := NewStatsdSink(addr) if err != nil { t.Fatalf("bad error") } s.SetGauge([]string{"gauge", "val"}, float32(1)) s.SetGaugeWithLabels([]string{"gauge_labels", "val"}, float32(2), []Label{{"a", "label"}}) s.EmitKey([]string{"key", "other"}, float32(3)) s.IncrCounter([]string{"counter", "me"}, float32(4)) s.IncrCounterWithLabels([]string{"counter_labels", "me"}, float32(5), []Label{{"a", "label"}}) s.AddSample([]string{"sample", "slow thingy"}, float32(6)) s.AddSampleWithLabels([]string{"sample_labels", "slow thingy"}, float32(7), []Label{{"a", "label"}}) select { case <-done: s.Shutdown() case <-time.After(3 time.Second): t.Fatalf("timeout") } } func TestNewStatsdSinkFromURL(t testing.T) { for _, tc := range []struct { desc string input string expectErr string expectAddr string }{ { desc: "address is populated", input: "statsd://statsd.service.consul", expectAddr: "statsd.service.consul", }, { desc: "address includes port", input: "statsd://statsd.service.consul:1234", expectAddr: "statsd.service.consul:1234", }, } { t.Run(tc.desc, func(t testing.T) { u, err := url.Parse(tc.input) if err != nil { t.Fatalf("error parsing URL: %s", err) } ms, err := NewStatsdSinkFromURL(u) if tc.expectErr != "" { if !strings.Contains(err.Error(), tc.expectErr) { t.Fatalf("expected err: %q, to contain: %q", err, tc.expectErr) } } else { if err != nil { t.Fatalf("unexpected err: %s", err) } is := ms.(*StatsdSink) if is.addr != tc.expectAddr { t.Fatalf("expected addr %s, got: %s", tc.expectAddr, is.addr) } } }) } }	3.87 KB	2025-05-25 12:27
📄 statsite.go package metrics import ( "bufio" "fmt" "log" "net" "net/url" "strings" "time" ) const ( // We force flush the statsite metrics after this period of // inactivity. Prevents stats from getting stuck in a buffer // forever. flushInterval = 100 * time.Millisecond ) // NewStatsiteSinkFromURL creates an StatsiteSink from a URL. It is used // (and tested) from NewMetricSinkFromURL. func NewStatsiteSinkFromURL(u url.URL) (MetricSink, error) { return NewStatsiteSink(u.Host) } // StatsiteSink provides a MetricSink that can be used with a // statsite metrics server type StatsiteSink struct { addr string metricQueue chan string } // NewStatsiteSink is used to create a new StatsiteSink func NewStatsiteSink(addr string) (StatsiteSink, error) { s := &StatsiteSink{ addr: addr, metricQueue: make(chan string, 4096), } go s.flushMetrics() return s, nil } // Close is used to stop flushing to statsite func (s StatsiteSink) Shutdown() { close(s.metricQueue) } func (s StatsiteSink) SetGauge(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|g\n", flatKey, val)) } func (s StatsiteSink) SetGaugeWithLabels(key []string, val float32, labels []Label) { flatKey := s.flattenKeyLabels(key, labels) s.pushMetric(fmt.Sprintf("%s:%f\|g\n", flatKey, val)) } func (s StatsiteSink) EmitKey(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|kv\n", flatKey, val)) } func (s StatsiteSink) IncrCounter(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|c\n", flatKey, val)) } func (s StatsiteSink) IncrCounterWithLabels(key []string, val float32, labels []Label) { flatKey := s.flattenKeyLabels(key, labels) s.pushMetric(fmt.Sprintf("%s:%f\|c\n", flatKey, val)) } func (s StatsiteSink) AddSample(key []string, val float32) { flatKey := s.flattenKey(key) s.pushMetric(fmt.Sprintf("%s:%f\|ms\n", flatKey, val)) } func (s StatsiteSink) AddSampleWithLabels(key []string, val float32, labels []Label) { flatKey := s.flattenKeyLabels(key, labels) s.pushMetric(fmt.Sprintf("%s:%f\|ms\n", flatKey, val)) } // Flattens the key for formatting, removes spaces func (s StatsiteSink) flattenKey(parts []string) string { joined := strings.Join(parts, ".") return strings.Map(func(r rune) rune { switch r { case ':': fallthrough case ' ': return '_' default: return r } }, joined) } // Flattens the key along with labels for formatting, removes spaces func (s StatsiteSink) flattenKeyLabels(parts []string, labels []Label) string { for _, label := range labels { parts = append(parts, label.Value) } return s.flattenKey(parts) } // Does a non-blocking push to the metrics queue func (s StatsiteSink) pushMetric(m string) { select { case s.metricQueue <- m: default: } } // Flushes metrics func (s StatsiteSink) flushMetrics() { var sock net.Conn var err error var wait <-chan time.Time var buffered bufio.Writer ticker := time.NewTicker(flushInterval) defer ticker.Stop() CONNECT: // Attempt to connect sock, err = net.Dial("tcp", s.addr) if err != nil { log.Printf("[ERR] Error connecting to statsite! Err: %s", err) goto WAIT } // Create a buffered writer buffered = bufio.NewWriter(sock) for { select { case metric, ok := <-s.metricQueue: // Get a metric from the queue if !ok { goto QUIT } // Try to send to statsite _, err := buffered.Write([]byte(metric)) if err != nil { log.Printf("[ERR] Error writing to statsite! Err: %s", err) goto WAIT } case <-ticker.C: if err := buffered.Flush(); err != nil { log.Printf("[ERR] Error flushing to statsite! Err: %s", err) goto WAIT } } } WAIT: // Wait for a while wait = time.After(time.Duration(5) time.Second) for { select { // Dequeue the messages to avoid backlog case _, ok := <-s.metricQueue: if !ok { goto QUIT } case <-wait: goto CONNECT } } QUIT: s.metricQueue = nil }	3.93 KB	2025-05-25 12:27
📄 statsite_test.go package metrics import ( "bufio" "net" "net/url" "strings" "testing" "time" ) func TestStatsite_Flatten(t testing.T) { s := &StatsiteSink{} flat := s.flattenKey([]string{"a", "b", "c", "d"}) if flat != "a.b.c.d" { t.Fatalf("Bad flat") } } func TestStatsite_PushFullQueue(t testing.T) { q := make(chan string, 1) q <- "full" s := &StatsiteSink{metricQueue: q} s.pushMetric("omit") out := <-q if out != "full" { t.Fatalf("bad val %v", out) } select { case v := <-q: t.Fatalf("bad val %v", v) default: } } func TestStatsite_Conn(t testing.T) { addr := "localhost:7523" ln, _ := net.Listen("tcp", addr) done := make(chan bool) go func() { conn, err := ln.Accept() if err != nil { t.Fatalf("unexpected err %s", err) } reader := bufio.NewReader(conn) line, err := reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "gauge.val:1.000000\|g\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "gauge_labels.val.label:2.000000\|g\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "key.other:3.000000\|kv\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "counter.me:4.000000\|c\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "counter_labels.me.label:5.000000\|c\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "sample.slow_thingy:6.000000\|ms\n" { t.Fatalf("bad line %s", line) } line, err = reader.ReadString('\n') if err != nil { t.Fatalf("unexpected err %s", err) } if line != "sample_labels.slow_thingy.label:7.000000\|ms\n" { t.Fatalf("bad line %s", line) } conn.Close() done <- true }() s, err := NewStatsiteSink(addr) if err != nil { t.Fatalf("bad error") } s.SetGauge([]string{"gauge", "val"}, float32(1)) s.SetGaugeWithLabels([]string{"gauge_labels", "val"}, float32(2), []Label{{"a", "label"}}) s.EmitKey([]string{"key", "other"}, float32(3)) s.IncrCounter([]string{"counter", "me"}, float32(4)) s.IncrCounterWithLabels([]string{"counter_labels", "me"}, float32(5), []Label{{"a", "label"}}) s.AddSample([]string{"sample", "slow thingy"}, float32(6)) s.AddSampleWithLabels([]string{"sample_labels", "slow thingy"}, float32(7), []Label{{"a", "label"}}) select { case <-done: s.Shutdown() case <-time.After(3 time.Second): t.Fatalf("timeout") } } func TestNewStatsiteSinkFromURL(t testing.T) { for _, tc := range []struct { desc string input string expectErr string expectAddr string }{ { desc: "address is populated", input: "statsd://statsd.service.consul", expectAddr: "statsd.service.consul", }, { desc: "address includes port", input: "statsd://statsd.service.consul:1234", expectAddr: "statsd.service.consul:1234", }, } { t.Run(tc.desc, func(t testing.T) { u, err := url.Parse(tc.input) if err != nil { t.Fatalf("error parsing URL: %s", err) } ms, err := NewStatsiteSinkFromURL(u) if tc.expectErr != "" { if !strings.Contains(err.Error(), tc.expectErr) { t.Fatalf("expected err: %q, to contain: %q", err, tc.expectErr) } } else { if err != nil { t.Fatalf("unexpected err: %s", err) } is := ms.(*StatsiteSink) if is.addr != tc.expectAddr { t.Fatalf("expected addr %s, got: %s", tc.expectAddr, is.addr) } } }) } }	3.74 KB	2025-05-25 12:27

Edit File:

Terminal