feat: add the ability to set the views via the SDK constructor

experimental/CHANGELOG.md

@@ -8,6 +8,7 @@ All notable changes to experimental packages in this project will be documented
 
 ### :rocket: (Enhancement)
 
+* fix(add-views-to-node-sdk): added the ability to define meter views in `NodeSDK` [#3066](https://github.com/open-telemetry/opentelemetry-js/pull/3124) @weyert
 * feature(add-console-metrics-exporter): add ConsoleMetricExporter [#3120](https://github.com/open-telemetry/opentelemetry-js/pull/3120) @weyert
 * feature(prometheus-serialiser): export the unit block when unit is set in metric descriptor [#3066](https://github.com/open-telemetry/opentelemetry-js/pull/3041) @weyert
 

experimental/packages/opentelemetry-sdk-node/README.md

@@ -128,6 +128,10 @@ Configure a trace exporter. If an exporter OR span processor is not configured,
 
 Configure tracing parameters. These are the same trace parameters used to [configure a tracer](../../../packages/opentelemetry-sdk-trace-base/src/types.ts#L71).
 
+### views
+
+Configure views of your instruments and accepts an array of [View](../opentelemetry-sdk-metrics-base/src/view/View.ts)-instances. The parameter can be used to configure the explicit bucket sizes of histogram metrics.
+
 ### serviceName
 
 Configure the [service name](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/README.md#service).

experimental/packages/opentelemetry-sdk-node/src/sdk.ts

@@ -27,7 +27,7 @@ import {
   Resource,
   ResourceDetectionConfig
 } from '@opentelemetry/resources';
-import { MeterProvider, MetricReader } from '@opentelemetry/sdk-metrics-base';
+import { MeterProvider, MetricReader, View } from '@opentelemetry/sdk-metrics-base';
 import {
   BatchSpanProcessor,
   SpanProcessor
@@ -37,15 +37,29 @@ import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'
 import { NodeSDKConfiguration } from './types';
 
 /** This class represents everything needed to register a fully configured OpenTelemetry Node.js SDK */
+
+export type MeterProviderConfig = {
+  /**
+   * Reference to the MetricReader instance by the NodeSDK
+   */
+  reader?: MetricReader
+  /**
+   * Lists the views that should be passed when meterProvider
+   *
+   * Note: This is only getting used when NodeSDK is responsible for
+   * instantiated an instance of MeterProvider
+   */
+  views?: View[]
+};
 export class NodeSDK {
   private _tracerProviderConfig?: {
     tracerConfig: NodeTracerConfig;
     spanProcessor: SpanProcessor;
     contextManager?: ContextManager;
     textMapPropagator?: TextMapPropagator;
   };
+  private _meterProviderConfig?: MeterProviderConfig;
   private _instrumentations: InstrumentationOption[];
-  private _metricReader?: MetricReader;
 
   private _resource: Resource;
 
@@ -87,8 +101,8 @@ export class NodeSDK {
       );
     }
 
-    if (configuration.metricReader) {
-      this.configureMeterProvider(configuration.metricReader);
+    if (configuration.metricReader || configuration.views) {
+      this.configureMeterProvider({ reader: configuration.metricReader, views: configuration.views });
     }
 
     let instrumentations: InstrumentationOption[] = [];
@@ -114,16 +128,20 @@ export class NodeSDK {
   }
 
   /** Set configurations needed to register a MeterProvider */
-  public configureMeterProvider(reader: MetricReader): void {
-    this._metricReader = reader;
+  public configureMeterProvider(config: MeterProviderConfig): void {
+    this._meterProviderConfig = config;
+
+    if (!this._meterProviderConfig.reader && this._meterProviderConfig.views) {
+      throw new Error('You have not passed a MetricReader instance but have passed Views, you need to manually pass the Views to your MeterProvider instance.');
+    }
   }
 
   /** Detect resource attributes */
   public async detectResources(
     config?: ResourceDetectionConfig
   ): Promise<void> {
     const internalConfig: ResourceDetectionConfig = {
-      detectors: [ envDetector, processDetector],
+      detectors: [envDetector, processDetector],
       ...config,
     };
 
@@ -146,7 +164,7 @@ export class NodeSDK {
     this._resource = this._serviceName === undefined
       ? this._resource
       : this._resource.merge(new Resource(
-        {[SemanticResourceAttributes.SERVICE_NAME]: this._serviceName}
+        { [SemanticResourceAttributes.SERVICE_NAME]: this._serviceName }
       ));
 
     if (this._tracerProviderConfig) {
@@ -164,12 +182,13 @@ export class NodeSDK {
       });
     }
 
-    if (this._metricReader) {
+    if (this._meterProviderConfig?.reader) {
       const meterProvider = new MeterProvider({
         resource: this._resource,
+        views: this._meterProviderConfig?.views ?? [],
       });
 
-      meterProvider.addMetricReader(this._metricReader);
+      meterProvider.addMetricReader(this._meterProviderConfig.reader);
 
       this._meterProvider = meterProvider;
 

experimental/packages/opentelemetry-sdk-node/src/types.ts

@@ -18,7 +18,7 @@ import type { ContextManager, SpanAttributes } from '@opentelemetry/api';
 import { TextMapPropagator } from '@opentelemetry/api';
 import { InstrumentationOption } from '@opentelemetry/instrumentation';
 import { Resource } from '@opentelemetry/resources';
-import { MetricReader } from '@opentelemetry/sdk-metrics-base';
+import { MetricReader, View } from '@opentelemetry/sdk-metrics-base';
 import {
   Sampler,
   SpanExporter,
@@ -32,6 +32,7 @@ export interface NodeSDKConfiguration {
   defaultAttributes: SpanAttributes;
   textMapPropagator: TextMapPropagator;
   metricReader: MetricReader;
+  views: View[]
   instrumentations: InstrumentationOption[];
   resource: Resource;
   sampler: Sampler;

experimental/packages/opentelemetry-sdk-node/test/sdk.test.ts

@@ -28,7 +28,7 @@ import {
   AsyncLocalStorageContextManager,
 } from '@opentelemetry/context-async-hooks';
 import { CompositePropagator } from '@opentelemetry/core';
-import { ConsoleMetricExporter, MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics-base';
+import { AggregationTemporality, ConsoleMetricExporter, InMemoryMetricExporter, InstrumentType, MeterProvider, PeriodicExportingMetricReader, View } from '@opentelemetry/sdk-metrics-base';
 import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import {
   assertServiceResource,
@@ -147,6 +147,106 @@ describe('Node SDK', () => {
     });
   });
 
+  it('should register meter views when provided', async () => {
+    async function waitForNumberOfMetrics(exporter: InMemoryMetricExporter, numberOfMetrics: number): Promise<void> {
+      if (numberOfMetrics <= 0) {
+        throw new Error('numberOfMetrics must be greater than or equal to 0');
+      }
+
+      let totalExports = 0;
+      while (totalExports < numberOfMetrics) {
+        await new Promise(resolve => setTimeout(resolve, 20));
+        const exportedMetrics = exporter.getMetrics();
+        totalExports = exportedMetrics.length;
+      }
+    }
+
+    const exporter = new InMemoryMetricExporter(AggregationTemporality.CUMULATIVE);
+    const metricReader = new PeriodicExportingMetricReader({
+      exporter: exporter,
+      exportIntervalMillis: 100,
+      exportTimeoutMillis: 100
+    });
+
+    const sdk = new NodeSDK({
+      metricReader: metricReader,
+      views: [
+        new View({
+          name: 'test-view',
+          instrumentName: 'test_counter',
+          instrumentType: InstrumentType.COUNTER,
+        })
+      ],
+      autoDetectResources: false,
+    });
+
+    await sdk.start();
+
+    assert.strictEqual(context['_getContextManager'](), ctxManager, 'context manager should not change');
+    assert.strictEqual(propagation['_getGlobalPropagator'](), propagator, 'propagator should not change');
+    assert.strictEqual((trace.getTracerProvider() as ProxyTracerProvider).getDelegate(), delegate, 'tracer provider should not have changed');
+
+    const meterProvider = metrics.getMeterProvider() as MeterProvider;
+    assert.ok(meterProvider);
+
+    const meter = meterProvider.getMeter('NodeSDKViews', '1.0.0');
+    const counter = meter.createCounter('test_counter', {
+      description: 'a test description',
+    });
+    counter.add(10);
+
+    await waitForNumberOfMetrics(exporter, 1);
+    const exportedMetrics = exporter.getMetrics();
+    const [firstExportedMetric] = exportedMetrics;
+    assert.ok(firstExportedMetric, 'should have one exported metric');
+    const [firstScopeMetric] = firstExportedMetric.scopeMetrics;
+    assert.ok(firstScopeMetric, 'should have one scope metric');
+    assert.ok(firstScopeMetric.scope.name === 'NodeSDKViews', 'scope should match created view');
+    assert.ok(firstScopeMetric.metrics.length > 0, 'should have at least one metrics entry');
+    const [firstMetricRecord] = firstScopeMetric.metrics;
+    assert.ok(firstMetricRecord.descriptor.name === 'test-view', 'should have renamed counter metric');
+
+    await sdk.shutdown();
+  });
+
+  it('should warn user when meter views are provided but not a MetricReader', async () => {
+    assert.throws(
+      () => {
+        new NodeSDK({
+          views: [
+            new View({
+              name: 'test-view',
+              instrumentName: 'test_counter',
+              instrumentType: InstrumentType.COUNTER,
+            })
+          ],
+          autoDetectResources: false,
+        });
+      }, (error: Error) => {
+        return error.message === 'You have not passed a MetricReader instance but have passed Views, you need to manually pass the Views to your MeterProvider instance.';
+      });
+  });
+
+  it('should warn user when meter views are provided but not a MetricReader when calling configureMeterProvider', async () => {
+    assert.throws(
+      () => {
+        const sdk = new NodeSDK({
+          autoDetectResources: false,
+        });
+        sdk.configureMeterProvider({
+          views: [
+            new View({
+              name: 'test-view',
+              instrumentName: 'test_counter',
+              instrumentType: InstrumentType.COUNTER,
+            })
+          ],
+        })
+      }, (error: Error) => {
+        return error.message === 'You have not passed a MetricReader instance but have passed Views, you need to manually pass the Views to your MeterProvider instance.';
+      });
+  });
+
   describe('detectResources', async () => {
     beforeEach(() => {
       process.env.OTEL_RESOURCE_ATTRIBUTES =
@@ -163,12 +263,12 @@ describe('Node SDK', () => {
           autoDetectResources: true,
         });
         await sdk.detectResources({
-          detectors: [ processDetector, {
+          detectors: [processDetector, {
             detect() {
               throw new Error('Buggy detector');
             }
           },
-          envDetector ]
+            envDetector]
         });
         const resource = sdk['_resource'];
 
@@ -277,7 +377,7 @@ describe('Node SDK', () => {
     });
 
     it('should configure service name via OTEL_SERVICE_NAME env var', async () => {
-      process.env.OTEL_SERVICE_NAME='env-set-name';
+      process.env.OTEL_SERVICE_NAME = 'env-set-name';
       const sdk = new NodeSDK();
 
       await sdk.start();
@@ -290,7 +390,7 @@ describe('Node SDK', () => {
     });
 
     it('should favor config set service name over OTEL_SERVICE_NAME env set service name', async () => {
-      process.env.OTEL_SERVICE_NAME='env-set-name';
+      process.env.OTEL_SERVICE_NAME = 'env-set-name';
       const sdk = new NodeSDK({
         serviceName: 'config-set-name',
       });