Metric attributes are used for filtering, aggregation, statistical, and other high-level operations in higher-level metric usage. In the monitoring alerts component of the GoFrame framework, three types of attribute injection methods are provided: constant attributes, variable attributes, and global attributes.

Metrics - Attributes - 图1tip

In OpenTelemetry, they are called metric attributes (attributes), but in Prometheus, they are called metric labels (labels), both meaning the same.

Constant Attributes

Constant attributes are a set of fixed attribute key-value pairs that can be bound to a Meter or directly to a metric object. If bound to a Meter, all metric objects created under the Meter carry this attribute key-value pair. If bound to a metric object, it will only be effective on the current metric. Let’s look at an example:

  1. package main
  3. import (
  4.     "context"
  6.     "go.opentelemetry.io/otel/exporters/prometheus"
  8.     "github.com/gogf/gf/contrib/metric/otelmetric/v2"
  9.     "github.com/gogf/gf/v2/frame/g"
  10.     "github.com/gogf/gf/v2/os/gctx"
  11.     "github.com/gogf/gf/v2/os/gmetric"
  12. )
  14. const (
  15.     instrument        = "github.com/gogf/gf/example/metric/basic"
  16.     instrumentVersion = "v1.0"
  17. )
  19. var (
  20.     meter = gmetric.GetGlobalProvider().Meter(gmetric.MeterOption{
  21.         Instrument:        instrument,
  22.         InstrumentVersion: instrumentVersion,
  23.         Attributes: gmetric.Attributes{
  24.             gmetric.NewAttribute("meter_const_attr_1", 1),
  25.         },
  26.     })
  27.     counter = meter.MustCounter(
  28.         "goframe.metric.demo.counter",
  29.         gmetric.MetricOption{
  30.             Help: "This is a simple demo for Counter usage",
  31.             Unit: "bytes",
  32.             Attributes: gmetric.Attributes{
  33.                 gmetric.NewAttribute("metric_const_attr_1", 1),
  34.             },
  35.         },
  36.     )
  37.     observableCounter = meter.MustObservableCounter(
  38.         "goframe.metric.demo.observable_counter",
  39.         gmetric.MetricOption{
  40.             Help: "This is a simple demo for ObservableCounter usage",
  41.             Unit: "%",
  42.             Attributes: gmetric.Attributes{
  43.                 gmetric.NewAttribute("metric_const_attr_2", 2),
  44.             },
  45.         },
  46.     )
  47. )
  49. func main() {
  50.     var ctx = gctx.New()
  51.     // Callback for observable metrics.
  52.     meter.MustRegisterCallback(func(ctx context.Context, obs gmetric.Observer) error {
  53.         obs.Observe(observableCounter, 10)
  54.         return nil
  55.     }, observableCounter)
  57.     // Prometheus exporter to export metrics as Prometheus format.
  58.     exporter, err := prometheus.New(
  59.         prometheus.WithoutCounterSuffixes(),
  60.         prometheus.WithoutUnits(),
  61.     )
  62.     if err != nil {
  63.         g.Log().Fatal(ctx, err)
  64.     }
  66.     // OpenTelemetry provider.
  67.     provider := otelmetric.MustProvider(
  68.         otelmetric.WithReader(exporter),
  69.     )
  70.     provider.SetAsGlobal()
  71.     defer provider.Shutdown(ctx)
  73.     // Counter.
  74.     counter.Inc(ctx)
  75.     counter.Add(ctx, 10)
  77.     // HTTP Server for metrics exporting.
  78.     otelmetric.StartPrometheusMetricsServer(8000, "/metrics")
  79. }

As you can see, we specify constant attributes through the Attributes attribute field in the MeterOption or MetricOption parameters when creating a Meter object or a Metric object.

Once executed, we visit http://127.0.0.1:8000/metrics to see the results. The constant attributes bound to the Meter took effect on both metrics, but the constant attributes bound to each metric only took effect on the corresponding metric.

Metrics - Attributes - 图2

Variable Attributes

Variable attributes are attribute key-value pairs specified at runtime, usually determined only at runtime, and might vary based on different execution scenarios, hence called variable attributes.

Let’s look at an example:

  1. package main
  3. import (
  4.     "context"
  6.     "go.opentelemetry.io/otel/exporters/prometheus"
  8.     "github.com/gogf/gf/contrib/metric/otelmetric/v2"
  9.     "github.com/gogf/gf/v2/frame/g"
  10.     "github.com/gogf/gf/v2/os/gctx"
  11.     "github.com/gogf/gf/v2/os/gmetric"
  12. )
  14. const (
  15.     instrument        = "github.com/gogf/gf/example/metric/basic"
  16.     instrumentVersion = "v1.0"
  17. )
  19. var (
  20.     meter = gmetric.GetGlobalProvider().Meter(gmetric.MeterOption{
  21.         Instrument:        instrument,
  22.         InstrumentVersion: instrumentVersion,
  23.         Attributes: gmetric.Attributes{
  24.             gmetric.NewAttribute("meter_const_attr_1", 1),
  25.         },
  26.     })
  27.     counter = meter.MustCounter(
  28.         "goframe.metric.demo.counter",
  29.         gmetric.MetricOption{
  30.             Help: "This is a simple demo for Counter usage",
  31.             Unit: "bytes",
  32.             Attributes: gmetric.Attributes{
  33.                 gmetric.NewAttribute("metric_const_attr_1", 1),
  34.             },
  35.         },
  36.     )
  37.     observableCounter = meter.MustObservableCounter(
  38.         "goframe.metric.demo.observable_counter",
  39.         gmetric.MetricOption{
  40.             Help: "This is a simple demo for ObservableCounter usage",
  41.             Unit: "%",
  42.             Attributes: gmetric.Attributes{
  43.                 gmetric.NewAttribute("metric_const_attr_2", 2),
  44.             },
  45.         },
  46.     )
  47. )
  49. func main() {
  50.     var ctx = gctx.New()
  51.     // Callback for observable metrics.
  52.     meter.MustRegisterCallback(func(ctx context.Context, obs gmetric.Observer) error {
  53.         obs.Observe(observableCounter, 10, gmetric.Option{
  54.             Attributes: gmetric.Attributes{
  55.                 gmetric.NewAttribute("dynamic_attr_1", 1),
  56.             },
  57.         })
  58.         return nil
  59.     }, observableCounter)
  61.     // Prometheus exporter to export metrics as Prometheus format.
  62.     exporter, err := prometheus.New(
  63.         prometheus.WithoutCounterSuffixes(),
  64.         prometheus.WithoutUnits(),
  65.     )
  66.     if err != nil {
  67.         g.Log().Fatal(ctx, err)
  68.     }
  70.     // OpenTelemetry provider.
  71.     provider := otelmetric.MustProvider(
  72.         otelmetric.WithReader(exporter),
  73.     )
  74.     provider.SetAsGlobal()
  75.     defer provider.Shutdown(ctx)
  77.     // Counter.
  78.     counter.Inc(ctx, gmetric.Option{
  79.         Attributes: gmetric.Attributes{
  80.             gmetric.NewAttribute("dynamic_attr_2", 2),
  81.         },
  82.     })
  83.     counter.Add(ctx, 10, gmetric.Option{
  84.         Attributes: gmetric.Attributes{
  85.             gmetric.NewAttribute("dynamic_attr_3", 3),
  86.         },
  87.     })
  89.     // HTTP Server for metrics exporting.
  90.     otelmetric.StartPrometheusMetricsServer(8000, "/metrics")
  91. }

As shown, we specify metric variable attributes at runtime through the Attributes attribute field in the Option parameter. Variable attributes are quite flexible, and the same metric can use different variable attributes.

Similarly, after execution, we visit http://127.0.0.1:8000/metrics to see the results.

Metrics - Attributes - 图3

Global Attributes

Global attributes are a more flexible metric attribute injection method, which can be automatically injected based on Instrument information and can determine whether to inject metric attributes into all metrics under a given Instrument based on regex matches of the Instrument name.

Let’s look at an example:

  1. package main
  3. import (
  4.     "context"
  6.     "go.opentelemetry.io/otel/exporters/prometheus"
  8.     "github.com/gogf/gf/contrib/metric/otelmetric/v2"
  9.     "github.com/gogf/gf/v2/frame/g"
  10.     "github.com/gogf/gf/v2/os/gctx"
  11.     "github.com/gogf/gf/v2/os/gmetric"
  12. )
  14. const (
  15.     instrument        = "github.com/gogf/gf/example/metric/basic"
  16.     instrumentVersion = "v1.0"
  17. )
  19. var (
  20.     meter = gmetric.GetGlobalProvider().Meter(gmetric.MeterOption{
  21.         Instrument:        instrument,
  22.         InstrumentVersion: instrumentVersion,
  23.         Attributes: gmetric.Attributes{
  24.             gmetric.NewAttribute("meter_const_attr_1", 1),
  25.         },
  26.     })
  27.     counter = meter.MustCounter(
  28.         "goframe.metric.demo.counter",
  29.         gmetric.MetricOption{
  30.             Help: "This is a simple demo for Counter usage",
  31.             Unit: "bytes",
  32.             Attributes: gmetric.Attributes{
  33.                 gmetric.NewAttribute("metric_const_attr_1", 1),
  34.             },
  35.         },
  36.     )
  37.     observableCounter = meter.MustObservableCounter(
  38.         "goframe.metric.demo.observable_counter",
  39.         gmetric.MetricOption{
  40.             Help: "This is a simple demo for ObservableCounter usage",
  41.             Unit: "%",
  42.             Attributes: gmetric.Attributes{
  43.                 gmetric.NewAttribute("metric_const_attr_2", 2),
  44.             },
  45.         },
  46.     )
  47. )
  49. func main() {
  50.     var ctx = gctx.New()
  52.     gmetric.SetGlobalAttributes(gmetric.Attributes{
  53.         gmetric.NewAttribute("global_attr_1", 1),
  54.     }, gmetric.SetGlobalAttributesOption{
  55.         Instrument:        instrument,
  56.         InstrumentVersion: instrumentVersion,
  57.         InstrumentPattern: "",
  58.     })
  60.     // Callback for observable metrics.
  61.     meter.MustRegisterCallback(func(ctx context.Context, obs gmetric.Observer) error {
  62.         obs.Observe(observableCounter, 10, gmetric.Option{
  63.             Attributes: gmetric.Attributes{
  64.                 gmetric.NewAttribute("dynamic_attr_1", 1),
  65.             },
  66.         })
  67.         return nil
  68.     }, observableCounter)
  70.     // Prometheus exporter to export metrics as Prometheus format.
  71.     exporter, err := prometheus.New(
  72.         prometheus.WithoutCounterSuffixes(),
  73.         prometheus.WithoutUnits(),
  74.     )
  75.     if err != nil {
  76.         g.Log().Fatal(ctx, err)
  77.     }
  79.     // OpenTelemetry provider.
  80.     provider := otelmetric.MustProvider(
  81.         otelmetric.WithReader(exporter),
  82.     )
  83.     provider.SetAsGlobal()
  84.     defer provider.Shutdown(ctx)
  86.     // Counter.
  87.     counter.Inc(ctx, gmetric.Option{
  88.         Attributes: gmetric.Attributes{
  89.             gmetric.NewAttribute("dynamic_attr_2", 2),
  90.         },
  91.     })
  92.     counter.Add(ctx, 10, gmetric.Option{
  93.         Attributes: gmetric.Attributes{
  94.             gmetric.NewAttribute("dynamic_attr_3", 3),
  95.         },
  96.     })
  98.     // HTTP Server for metrics exporting.
  99.     otelmetric.StartPrometheusMetricsServer(8000, "/metrics")
  100. }

Set global attributes through the gmetric.SetGlobalAttributes method, and restrict the affected metric range based on the parameter gmetric.SetGlobalAttributesOption.

Similarly, after execution, visit http://127.0.0.1:8000/metrics to see the results. You can see that the global attributes have been automatically added to the metrics.

Metrics - Attributes - 图4