feat(sdk-metrics): adds the cardinalitySelector argument to PeriodicExportingMetricReaders

packages/sdk-metrics/src/export/PeriodicExportingMetricReader.ts

@@ -13,6 +13,7 @@ import { MetricReader } from './MetricReader';
 import type { PushMetricExporter } from './MetricExporter';
 import { callWithTimeout, TimeoutError } from '../utils';
 import type { MetricProducer } from './MetricProducer';
+import { InstrumentType } from './MetricData';
 
 export type PeriodicExportingMetricReaderOptions = {
   /**
@@ -35,6 +36,20 @@ export type PeriodicExportingMetricReaderOptions = {
    * @experimental
    */
   metricProducers?: MetricProducer[];
+  /**
+   * Cardinality limits for the metric reader, applied per instrument. If not configured, defaults to 2000 time series per instrument. These are wrapped in a cardinalitySelector function that returns limits based on the instrument type, so they can be configured differently per type if desired.
+   *
+   */
+  cardinalityLimits?: {
+    counter?: number;
+    gauge?: number;
+    histogram?: number;
+    upDownCounter?: number;
+    observableCounter?: number;
+    observableGauge?: number;
+    observableUpDownCounter?: number;
+    default?: number;
+  };
 };
 
 /**
@@ -48,14 +63,51 @@ export class PeriodicExportingMetricReader extends MetricReader {
   private readonly _exportTimeout: number;
 
   constructor(options: PeriodicExportingMetricReaderOptions) {
-    const { exporter, exportIntervalMillis = 60000, metricProducers } = options;
+    const {
+      exporter,
+      exportIntervalMillis = 60000,
+      metricProducers,
+      cardinalityLimits,
+    } = options;
     let { exportTimeoutMillis = 30000 } = options;
 
     super({
       aggregationSelector: exporter.selectAggregation?.bind(exporter),
       aggregationTemporalitySelector:
         exporter.selectAggregationTemporality?.bind(exporter),
       metricProducers,
+      cardinalitySelector: (instrumentType: InstrumentType) => {
+        const limits = {
+          counter: 2000,
+          gauge: 2000,
+          histogram: 2000,
+          upDownCounter: 2000,
+          observableCounter: 2000,
+          observableGauge: 2000,
+          observableUpDownCounter: 2000,
+          default: 2000,
+          ...(cardinalityLimits ?? {}),
+        };
+
+        switch (instrumentType) {
+          case InstrumentType.COUNTER:
+            return limits.counter;
+          case InstrumentType.GAUGE:
+            return limits.gauge;
+          case InstrumentType.HISTOGRAM:
+            return limits.histogram;
+          case InstrumentType.OBSERVABLE_COUNTER:
+            return limits.observableCounter;
+          case InstrumentType.OBSERVABLE_UP_DOWN_COUNTER:
+            return limits.observableUpDownCounter;
+          case InstrumentType.OBSERVABLE_GAUGE:
+            return limits.observableGauge;
+          case InstrumentType.UP_DOWN_COUNTER:
+            return limits.upDownCounter;
+          default:
+            return limits.default;
+        }
+      },
     });
 
     if (exportIntervalMillis <= 0) {

packages/sdk-metrics/test/export/PeriodicExportingMetricReader.test.ts

@@ -8,10 +8,10 @@ import { AggregationTemporality } from '../../src/export/AggregationTemporality'
 import type {
   AggregationOption,
   CollectionResult,
-  InstrumentType,
   MetricProducer,
   PushMetricExporter,
 } from '../../src';
+import { InstrumentType } from '../../src/export/MetricData';
 import { AggregationType } from '../../src';
 import type {
   ResourceMetrics,
@@ -250,6 +250,44 @@ describe('PeriodicExportingMetricReader', () => {
     });
   });
 
+  describe('cardinalityLimits', () => {
+    it('should use default cardinality limits with no exporter preference', () => {
+      const exporter = new TestDeltaMetricExporter();
+
+      const p = new PeriodicExportingMetricReader({
+        exporter,
+        exportIntervalMillis: 1,
+        exportTimeoutMillis: 1,
+      });
+
+      assert.strictEqual(
+        p.selectCardinalityLimit(InstrumentType.COUNTER),
+        2000
+      );
+    });
+
+    it('provided cardinalityLimits over defaults', () => {
+      const exporter = new TestDeltaMetricExporter();
+
+      const p = new PeriodicExportingMetricReader({
+        exporter,
+        exportIntervalMillis: 1,
+        exportTimeoutMillis: 1,
+        cardinalityLimits: {
+          counter: 5000,
+          gauge: 5000,
+          histogram: 5000,
+          default: 5000,
+        },
+      });
+
+      assert.strictEqual(
+        p.selectCardinalityLimit(InstrumentType.COUNTER),
+        5000
+      );
+    });
+  });
+
   describe('setMetricProducer', () => {
     it('should start exporting periodically', async () => {
       const exporter = new TestMetricExporter();