Merge pull request #2433 from grafana/refactor/move_stats_to_metrics

Move the `stats` package content to `metrics` package

.github/workflows/xk6-tests/xk6-js-test/jstest.go

@@ -5,7 +5,7 @@ import (
 	"time"
 
 	"go.k6.io/k6/js/modules"
-	"go.k6.io/k6/stats"
+	"go.k6.io/k6/metrics"
 )
 
 func init() {
@@ -19,7 +19,7 @@ type (
 	JSTest struct {
 		vu modules.VU
 
-		foos *stats.Metric
+		foos *metrics.Metric
 	}
 )
 
@@ -39,7 +39,7 @@ func New() *RootModule {
 func (*RootModule) NewModuleInstance(vu modules.VU) modules.Instance {
 	return &JSTest{
 		vu:   vu,
-		foos: vu.InitEnv().Registry.MustNewMetric("foos", stats.Counter),
+		foos: vu.InitEnv().Registry.MustNewMetric("foos", metrics.Counter),
 	}
 }
 
@@ -60,9 +60,9 @@ func (j *JSTest) Foo(arg float64) (bool, error) {
 
 	tags := state.CloneTags()
 	tags["foo"] = "bar"
-	stats.PushIfNotDone(ctx, state.Samples, stats.Sample{
+	metrics.PushIfNotDone(ctx, state.Samples, metrics.Sample{
 		Time:   time.Now(),
-		Metric: j.foos, Tags: stats.IntoSampleTags(&tags),
+		Metric: j.foos, Tags: metrics.IntoSampleTags(&tags),
 		Value: arg,
 	})
 

.github/workflows/xk6-tests/xk6-output-test/outputtest.go

@@ -22,9 +22,9 @@ package outputtest
 import (
 	"strconv"
 
-	"go.k6.io/k6/output"
-	"go.k6.io/k6/stats"
 	"github.com/spf13/afero"
+	"go.k6.io/k6/metrics"
+	"go.k6.io/k6/output"
 )
 
 func init() {
@@ -57,7 +57,7 @@ func (o *Output) Start() error {
 }
 
 // AddMetricSamples just plucks out the metric we're interested in.
-func (o *Output) AddMetricSamples(sampleContainers []stats.SampleContainer) {
+func (o *Output) AddMetricSamples(sampleContainers []metrics.SampleContainer) {
 	for _, sc := range sampleContainers {
 		for _, sample := range sc.GetSamples() {
 			if sample.Metric.Name == "foos" {

api/v1/metric.go

@@ -27,11 +27,11 @@ import (
 
 	"gopkg.in/guregu/null.v3"
 
-	"go.k6.io/k6/stats"
+	"go.k6.io/k6/metrics"
 )
 
 type NullMetricType struct {
-	Type  stats.MetricType
+	Type  metrics.MetricType
 	Valid bool
 }
 
@@ -52,7 +52,7 @@ func (t *NullMetricType) UnmarshalJSON(data []byte) error {
 }
 
 type NullValueType struct {
-	Type  stats.ValueType
+	Type  metrics.ValueType
 	Valid bool
 }
 
@@ -82,7 +82,8 @@ type Metric struct {
 	Sample map[string]float64 `json:"sample" yaml:"sample"`
 }
 
-func NewMetric(m *stats.Metric, t time.Duration) Metric {
+// NewMetric constructs a new Metric
+func NewMetric(m *metrics.Metric, t time.Duration) Metric {
 	return Metric{
 		Name:     m.Name,
 		Type:     NullMetricType{m.Type, true},

api/v1/metric_jsonapi.go

@@ -23,7 +23,7 @@ package v1
 import (
 	"time"
 
-	"go.k6.io/k6/stats"
+	"go.k6.io/k6/metrics"
 )
 
 // MetricsJSONAPI is JSON API envelop for metrics
@@ -41,13 +41,13 @@ type metricData struct {
 	Attributes Metric `json:"attributes"`
 }
 
-func newMetricEnvelope(m *stats.Metric, t time.Duration) metricJSONAPI {
+func newMetricEnvelope(m *metrics.Metric, t time.Duration) metricJSONAPI {
 	return metricJSONAPI{
 		Data: newMetricData(m, t),
 	}
 }
 
-func newMetricsJSONAPI(list map[string]*stats.Metric, t time.Duration) MetricsJSONAPI {
+func newMetricsJSONAPI(list map[string]*metrics.Metric, t time.Duration) MetricsJSONAPI {
 	metrics := make([]metricData, 0, len(list))
 
 	for _, m := range list {
@@ -59,7 +59,7 @@ func newMetricsJSONAPI(list map[string]*stats.Metric, t time.Duration) MetricsJS
 	}
 }
 
-func newMetricData(m *stats.Metric, t time.Duration) metricData {
+func newMetricData(m *metrics.Metric, t time.Duration) metricData {
 	metric := NewMetric(m, t)
 
 	return metricData{

api/v1/metric_routes_test.go

@@ -37,7 +37,6 @@ import (
 	"go.k6.io/k6/lib/testutils"
 	"go.k6.io/k6/lib/testutils/minirunner"
 	"go.k6.io/k6/metrics"
-	"go.k6.io/k6/stats"
 )
 
 func TestGetMetrics(t *testing.T) {
@@ -47,14 +46,14 @@ func TestGetMetrics(t *testing.T) {
 	logger.SetOutput(testutils.NewTestOutput(t))
 	registry := metrics.NewRegistry()
 	builtinMetrics := metrics.RegisterBuiltinMetrics(registry)
-	testMetric, err := registry.NewMetric("my_metric", stats.Trend, stats.Time)
+	testMetric, err := registry.NewMetric("my_metric", metrics.Trend, metrics.Time)
 	require.NoError(t, err)
 	execScheduler, err := local.NewExecutionScheduler(&minirunner.MiniRunner{}, builtinMetrics, logger)
 	require.NoError(t, err)
 	engine, err := core.NewEngine(execScheduler, lib.Options{}, lib.RuntimeOptions{}, nil, logger, registry)
 	require.NoError(t, err)
 
-	engine.MetricsEngine.ObservedMetrics = map[string]*stats.Metric{
+	engine.MetricsEngine.ObservedMetrics = map[string]*metrics.Metric{
 		"my_metric": testMetric,
 	}
 	engine.MetricsEngine.ObservedMetrics["my_metric"].Tainted = null.BoolFrom(true)
@@ -81,18 +80,18 @@ func TestGetMetrics(t *testing.T) {
 		var envelop MetricsJSONAPI
 		assert.NoError(t, json.Unmarshal(rw.Body.Bytes(), &envelop))
 
-		metrics := envelop.Data
-		if !assert.Len(t, metrics, 1) {
+		metricsData := envelop.Data
+		if !assert.Len(t, metricsData, 1) {
 			return
 		}
 
-		metric := metrics[0].Attributes
+		metric := metricsData[0].Attributes
 
-		assert.Equal(t, "my_metric", metrics[0].ID)
+		assert.Equal(t, "my_metric", metricsData[0].ID)
 		assert.True(t, metric.Type.Valid)
-		assert.Equal(t, stats.Trend, metric.Type.Type)
+		assert.Equal(t, metrics.Trend, metric.Type.Type)
 		assert.True(t, metric.Contains.Valid)
-		assert.Equal(t, stats.Time, metric.Contains.Type)
+		assert.Equal(t, metrics.Time, metric.Contains.Type)
 		assert.True(t, metric.Tainted.Valid)
 		assert.True(t, metric.Tainted.Bool)
 
@@ -108,15 +107,15 @@ func TestGetMetric(t *testing.T) {
 	logger := logrus.New()
 	logger.SetOutput(testutils.NewTestOutput(t))
 	registry := metrics.NewRegistry()
-	testMetric, err := registry.NewMetric("my_metric", stats.Trend, stats.Time)
+	testMetric, err := registry.NewMetric("my_metric", metrics.Trend, metrics.Time)
 	require.NoError(t, err)
 	builtinMetrics := metrics.RegisterBuiltinMetrics(registry)
 	execScheduler, err := local.NewExecutionScheduler(&minirunner.MiniRunner{}, builtinMetrics, logger)
 	require.NoError(t, err)
 	engine, err := core.NewEngine(execScheduler, lib.Options{}, lib.RuntimeOptions{}, nil, logger, registry)
 	require.NoError(t, err)
 
-	engine.MetricsEngine.ObservedMetrics = map[string]*stats.Metric{
+	engine.MetricsEngine.ObservedMetrics = map[string]*metrics.Metric{
 		"my_metric": testMetric,
 	}
 	engine.MetricsEngine.ObservedMetrics["my_metric"].Tainted = null.BoolFrom(true)
@@ -156,9 +155,9 @@ func TestGetMetric(t *testing.T) {
 
 			assert.Equal(t, "my_metric", envelop.Data.ID)
 			assert.True(t, metric.Type.Valid)
-			assert.Equal(t, stats.Trend, metric.Type.Type)
+			assert.Equal(t, metrics.Trend, metric.Type.Type)
 			assert.True(t, metric.Contains.Valid)
-			assert.Equal(t, stats.Time, metric.Contains.Type)
+			assert.Equal(t, metrics.Time, metric.Contains.Type)
 			assert.True(t, metric.Tainted.Valid)
 			assert.True(t, metric.Tainted.Bool)
 		})

api/v1/metric_test.go

@@ -29,18 +29,17 @@ import (
 	"gopkg.in/guregu/null.v3"
 
 	"go.k6.io/k6/metrics"
-	"go.k6.io/k6/stats"
 )
 
 func TestNullMetricTypeJSON(t *testing.T) {
 	t.Parallel()
 
 	values := map[NullMetricType]string{
-		{}:                    `null`,
-		{stats.Counter, true}: `"counter"`,
-		{stats.Gauge, true}:   `"gauge"`,
-		{stats.Trend, true}:   `"trend"`,
-		{stats.Rate, true}:    `"rate"`,
+		{}:                      `null`,
+		{metrics.Counter, true}: `"counter"`,
+		{metrics.Gauge, true}:   `"gauge"`,
+		{metrics.Trend, true}:   `"trend"`,
+		{metrics.Rate, true}:    `"rate"`,
 	}
 	t.Run("Marshal", func(t *testing.T) {
 		t.Parallel()
@@ -74,9 +73,9 @@ func TestNullValueTypeJSON(t *testing.T) {
 	t.Parallel()
 
 	values := map[NullValueType]string{
-		{}:                    `null`,
-		{stats.Default, true}: `"default"`,
-		{stats.Time, true}:    `"time"`,
+		{}:                      `null`,
+		{metrics.Default, true}: `"default"`,
+		{metrics.Time, true}:    `"time"`,
 	}
 	t.Run("Marshal", func(t *testing.T) {
 		t.Parallel()
@@ -109,16 +108,16 @@ func TestNullValueTypeJSON(t *testing.T) {
 func TestNewMetric(t *testing.T) {
 	t.Parallel()
 
-	old, err := metrics.NewRegistry().NewMetric("test_metric", stats.Trend, stats.Time)
+	old, err := metrics.NewRegistry().NewMetric("test_metric", metrics.Trend, metrics.Time)
 	require.NoError(t, err)
 	old.Tainted = null.BoolFrom(true)
 	m := NewMetric(old, 0)
 	assert.Equal(t, "test_metric", m.Name)
 	assert.True(t, m.Type.Valid)
-	assert.Equal(t, stats.Trend, m.Type.Type)
+	assert.Equal(t, metrics.Trend, m.Type.Type)
 	assert.True(t, m.Contains.Valid)
 	assert.True(t, m.Tainted.Bool)
 	assert.True(t, m.Tainted.Valid)
-	assert.Equal(t, stats.Time, m.Contains.Type)
+	assert.Equal(t, metrics.Time, m.Contains.Type)
 	assert.NotEmpty(t, m.Sample)
 }

cmd/config.go

@@ -39,7 +39,7 @@ import (
 	"go.k6.io/k6/lib"
 	"go.k6.io/k6/lib/executor"
 	"go.k6.io/k6/lib/types"
-	"go.k6.io/k6/stats"
+	"go.k6.io/k6/metrics"
 )
 
 // configFlagSet returns a FlagSet with the default run configuration flags.
@@ -201,7 +201,7 @@ func getConsolidatedConfig(globalState *globalState, cliConf Config, runnerOpts
 	// for CLI flags in cmd.getOptions, in case other configuration sources
 	// (e.g. env vars) overrode our default value. This is not done in
 	// lib.Options.Validate to avoid circular imports.
-	if _, err = stats.GetResolversForTrendColumns(conf.SummaryTrendStats); err != nil {
+	if _, err = metrics.GetResolversForTrendColumns(conf.SummaryTrendStats); err != nil {
 		return conf, err
 	}
 
@@ -214,7 +214,7 @@ func getConsolidatedConfig(globalState *globalState, cliConf Config, runnerOpts
 // Note that if you add option default value here, also add it in command line argument help text.
 func applyDefault(conf Config) Config {
 	if conf.Options.SystemTags == nil {
-		conf.Options.SystemTags = &stats.DefaultSystemTagSet
+		conf.Options.SystemTags = &metrics.DefaultSystemTagSet
 	}
 	if conf.Options.SummaryTrendStats == nil {
 		conf.Options.SummaryTrendStats = lib.DefaultSummaryTrendStats

cmd/config_consolidation_test.go

@@ -33,7 +33,7 @@ import (
 	"go.k6.io/k6/lib"
 	"go.k6.io/k6/lib/executor"
 	"go.k6.io/k6/lib/types"
-	"go.k6.io/k6/stats"
+	"go.k6.io/k6/metrics"
 )
 
 func verifyOneIterPerOneVU(t *testing.T, c Config) {
@@ -350,22 +350,22 @@ func getConfigConsolidationTestCases() []configConsolidationTestCase {
 
 		// Test system tags
 		{opts{}, exp{}, func(t *testing.T, c Config) {
-			assert.Equal(t, &stats.DefaultSystemTagSet, c.Options.SystemTags)
+			assert.Equal(t, &metrics.DefaultSystemTagSet, c.Options.SystemTags)
 		}},
 		{opts{cli: []string{"--system-tags", `""`}}, exp{}, func(t *testing.T, c Config) {
-			assert.Equal(t, stats.SystemTagSet(0), *c.Options.SystemTags)
+			assert.Equal(t, metrics.SystemTagSet(0), *c.Options.SystemTags)
 		}},
 		{
 			opts{
 				runner: &lib.Options{
-					SystemTags: stats.NewSystemTagSet(stats.TagSubproto, stats.TagURL),
+					SystemTags: metrics.NewSystemTagSet(metrics.TagSubproto, metrics.TagURL),
 				},
 			},
 			exp{},
 			func(t *testing.T, c Config) {
 				assert.Equal(
 					t,
-					*stats.NewSystemTagSet(stats.TagSubproto, stats.TagURL),
+					*metrics.NewSystemTagSet(metrics.TagSubproto, metrics.TagURL),
 					*c.Options.SystemTags,
 				)
 			},

cmd/integration_tests/eventloop/eventloop_test.go

@@ -20,7 +20,6 @@ import (
 	"go.k6.io/k6/lib/types"
 	"go.k6.io/k6/loader"
 	"go.k6.io/k6/metrics"
-	"go.k6.io/k6/stats"
 	"gopkg.in/guregu/null.v3"
 )
 
@@ -201,7 +200,7 @@ export default function() {
 
 func newTestExecutionScheduler(
 	t *testing.T, runner lib.Runner, logger *logrus.Logger, opts lib.Options, builtinMetrics *metrics.BuiltinMetrics,
-) (ctx context.Context, cancel func(), execScheduler *local.ExecutionScheduler, samples chan stats.SampleContainer) {
+) (ctx context.Context, cancel func(), execScheduler *local.ExecutionScheduler, samples chan metrics.SampleContainer) {
 	if runner == nil {
 		runner = &minirunner.MiniRunner{}
 	}
@@ -222,7 +221,7 @@ func newTestExecutionScheduler(
 	execScheduler, err = local.NewExecutionScheduler(runner, builtinMetrics, logger)
 	require.NoError(t, err)
 
-	samples = make(chan stats.SampleContainer, newOpts.MetricSamplesBufferSize.Int64)
+	samples = make(chan metrics.SampleContainer, newOpts.MetricSamplesBufferSize.Int64)
 	go func() {
 		for {
 			select {

cmd/options.go

@@ -32,7 +32,7 @@ import (
 	"go.k6.io/k6/lib"
 	"go.k6.io/k6/lib/consts"
 	"go.k6.io/k6/lib/types"
-	"go.k6.io/k6/stats"
+	"go.k6.io/k6/metrics"
 )
 
 var (
@@ -86,7 +86,7 @@ func optionFlagSet() *pflag.FlagSet {
 	// set it to nil here, and add the default in applyDefault() instead.
 	systemTagsCliHelpText := fmt.Sprintf(
 		"only include these system tags in metrics (default %q)",
-		stats.DefaultSystemTagSet.SetString(),
+		metrics.DefaultSystemTagSet.SetString(),
 	)
 	flags.StringSlice("system-tags", nil, systemTagsCliHelpText)
 	flags.StringSlice("tag", nil, "add a `tag` to be applied to all samples, as `[name]=[value]`")
@@ -181,7 +181,7 @@ func getOptions(flags *pflag.FlagSet) (lib.Options, error) {
 		if err != nil {
 			return opts, err
 		}
-		opts.SystemTags = stats.ToSystemTagSet(systemTagList)
+		opts.SystemTags = metrics.ToSystemTagSet(systemTagList)
 	}
 
 	blacklistIPStrings, err := flags.GetStringSlice("blacklist-ip")
@@ -223,7 +223,7 @@ func getOptions(flags *pflag.FlagSet) (lib.Options, error) {
 		if errSts != nil {
 			return opts, errSts
 		}
-		if _, errSts = stats.GetResolversForTrendColumns(trendStats); err != nil {
+		if _, errSts = metrics.GetResolversForTrendColumns(trendStats); err != nil {
 			return opts, errSts
 		}
 		opts.SummaryTrendStats = trendStats
@@ -255,7 +255,7 @@ func getOptions(flags *pflag.FlagSet) (lib.Options, error) {
 			}
 			parsedRunTags[name] = value
 		}
-		opts.RunTags = stats.IntoSampleTags(&parsedRunTags)
+		opts.RunTags = metrics.IntoSampleTags(&parsedRunTags)
 	}
 
 	redirectConFile, err := flags.GetString("console-output")