@opentelemetry/sdk-metrics-base

What is @opentelemetry/sdk-metrics-base?

@opentelemetry/sdk-metrics-base is a package that provides the core functionalities for collecting and reporting metrics in applications using OpenTelemetry. It allows developers to create and manage various types of metrics, such as counters, gauges, and histograms, and export them to different backends for monitoring and analysis.

What are @opentelemetry/sdk-metrics-base's main functionalities?

Creating a Meter

This code demonstrates how to create a MeterProvider and obtain a Meter instance. A Meter is used to create and manage metrics.

const { MeterProvider } = require('@opentelemetry/sdk-metrics-base');
const meterProvider = new MeterProvider();
const meter = meterProvider.getMeter('example-meter');

Creating a Counter

This code shows how to create a Counter metric and increment its value. Counters are used to count occurrences of events.

const counter = meter.createCounter('example_counter', {
  description: 'An example counter'
});
counter.add(10);

Creating a Histogram

This code demonstrates how to create a Histogram metric and record a value. Histograms are used to measure the distribution of values.

const histogram = meter.createHistogram('example_histogram', {
  description: 'An example histogram'
});
histogram.record(100);

Creating an UpDownCounter

This code shows how to create an UpDownCounter metric and adjust its value up or down. UpDownCounters are used to track values that can increase or decrease.

const upDownCounter = meter.createUpDownCounter('example_updowncounter', {
  description: 'An example updown counter'
});
upDownCounter.add(5);
upDownCounter.add(-3);

Exporting Metrics

This code demonstrates how to export metrics using a ConsoleMetricExporter. Metrics can be exported to various backends for monitoring and analysis.

const { ConsoleMetricExporter, PeriodicExportingMetricReader } = require('@opentelemetry/sdk-metrics-base');
const exporter = new ConsoleMetricExporter();
meterProvider.addMetricReader(new PeriodicExportingMetricReader({ exporter }));

Other packages similar to @opentelemetry/sdk-metrics-base

prom-client

prom-client is a Prometheus client for Node.js that allows you to create and manage metrics, such as counters, gauges, histograms, and summaries. It is similar to @opentelemetry/sdk-metrics-base in that it provides a way to collect and export metrics, but it is specifically designed for use with Prometheus.

statsd

statsd is a simple, lightweight daemon that listens for statistics, like counters and timers, sent over UDP or TCP and sends aggregates to one or more pluggable backend services (e.g., Graphite). It is similar to @opentelemetry/sdk-metrics-base in that it collects and reports metrics, but it is more focused on network-based metric collection.

newrelic

newrelic is a Node.js agent for New Relic, which provides performance monitoring and management for applications. It is similar to @opentelemetry/sdk-metrics-base in that it collects and reports metrics, but it is specifically designed to work with the New Relic platform.

README

OpenTelemetry Metrics SDK

OpenTelemetry metrics module contains the foundation for all metrics SDKs of opentelemetry-js.

Used standalone, this module provides methods for manual instrumentation of code, offering full control over recording metrics for client-side JavaScript (browser) and Node.js.

It does not provide automated instrumentation of known libraries or host environment metrics out-of-the-box.

Installation

npm install --save @opentelemetry/api-metrics
npm install --save @opentelemetry/sdk-metrics-base

Usage

The basic setup of the SDK can be seen as followings:

const opentelemetry = require('@opentelemetry/api-metrics');
const { MeterProvider } = require('@opentelemetry/sdk-metrics-base');

// To create an instrument, you first need to initialize the Meter provider.
// NOTE: The default OpenTelemetry meter provider does not record any metric instruments.
//       Registering a working meter provider allows the API methods to record instruments.
opentelemetry.setGlobalMeterProvider(new MeterProvider());

// To record a metric event, we used the global singleton meter to create an instrument.
const counter = opentelemetry.getMeter('default').createCounter('foo');

// record a metric event.
counter.add(1, { attributeKey: 'attribute-value' });

In conditions, we may need to setup an async instrument to observe costly events:

// Creating an async instrument, similar to synchronous instruments
const observableCounter = opentelemetry.getMeter('default')
  .createObservableCounter('observable-counter');

// Register a single-instrument callback to the async instrument.
observableCounter.addCallback(async (observableResult) => {
  // ... do async stuff
  observableResult.observe(1, { attributeKey: 'attribute-value' });
});

// Register a multi-instrument callback and associate it with a set of async instruments.
opentelemetry.getMeter('default')
  .addBatchObservableCallback(batchObservableCallback, [ observableCounter ]);
async function batchObservableCallback(batchObservableResult) {
  // ... do async stuff
  batchObservableResult.observe(observableCounter, 1, { attributeKey: 'attribute-value' });
}

Views can be registered when instantiating a MeterProvider:

const meterProvider = new MeterProvider({
  views: [
    // override the bucket boundaries on `my.histogram` to [0, 50, 100]
    new View({ aggregation: new ExplicitBucketHistogramAggregation([0, 50, 100]), instrumentName: 'my.histogram'}),
    // rename 'my.counter' to 'my.renamed.counter'
    new View({ name: 'my.renamed.counter', instrumentName: 'my.counter'})
  ]
})

Example

See examples/prometheus for an end-to-end example, including exporting metrics.

Useful links

• For more information on OpenTelemetry, visit: https://opentelemetry.io/
• For more about OpenTelemetry JavaScript: https://github.com/open-telemetry/opentelemetry-js
• For help or feedback on this project, join us in GitHub Discussions

License

Apache 2.0 - See LICENSE for more information.