feat(configuration): set MeterProvider on sdk start

experimental/CHANGELOG.md

@@ -15,6 +15,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
 
 * feat(configuration): add resource detection parsing [#6435](https://github.com/open-telemetry/opentelemetry-js/pull/6435) @MikeGoldsmith
 * feat(configuration): export interfaces required in other packages [#6462](https://github.com/open-telemetry/opentelemetry-js/pull/6462) @maryliag
+* feat(configuration): set MeterProvider on sdk start [#6463](https://github.com/open-telemetry/opentelemetry-js/pull/6463) @maryliag
 
 ### :bug: Bug Fixes
 

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

@@ -11,18 +11,22 @@ import {
   context,
   diag,
   DiagConsoleLogger,
+  metrics,
   propagation,
 } from '@opentelemetry/api';
 import {
   getInstanceID,
   getLogRecordProcessorsFromConfiguration,
+  getMeterReadersFromConfiguration,
+  getMeterViewsFromConfiguration,
   getPropagatorFromConfiguration,
   getResourceDetectorsFromConfiguration,
   getResourceFromConfiguration,
 } from './utils';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import type { SDKComponents, SDKOptions } from './types';
 import { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { MeterProvider } from '@opentelemetry/sdk-metrics';
 import { logs } from '@opentelemetry/api-logs';
 import type {
   Resource,
@@ -64,6 +68,9 @@ export function startNodeSDK(sdkOptions: SDKOptions): {
   if (components.loggerProvider) {
     logs.setGlobalLoggerProvider(components.loggerProvider);
   }
+  if (components.meterProvider) {
+    metrics.setGlobalMeterProvider(components.meterProvider);
+  }
   if (components.propagator) {
     propagation.setGlobalPropagator(components.propagator);
   }
@@ -73,6 +80,9 @@ export function startNodeSDK(sdkOptions: SDKOptions): {
     if (components.loggerProvider) {
       promises.push(components.loggerProvider.shutdown());
     }
+    if (components.meterProvider) {
+      promises.push(components.meterProvider.shutdown());
+    }
     await Promise.all(promises);
   };
   return { shutdown: shutdownFn };
@@ -113,6 +123,17 @@ function create(
     components.loggerProvider = loggerProvider;
   }
 
+  const meterReaders = getMeterReadersFromConfiguration(config);
+  if (meterReaders) {
+    const meterViews = getMeterViewsFromConfiguration(config);
+    const meterProvider = new MeterProvider({
+      resource: resource,
+      readers: meterReaders,
+      views: meterViews ?? [],
+    });
+    components.meterProvider = meterProvider;
+  }
+
   return components;
 }
 

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

@@ -11,6 +11,7 @@ import type {
   LoggerProvider,
   LogRecordProcessor,
 } from '@opentelemetry/sdk-logs';
+import type { MeterProvider } from '@opentelemetry/sdk-metrics';
 import type { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';
 import type {
   Sampler,
@@ -55,5 +56,6 @@ export interface SDKOptions {
 export interface SDKComponents {
   contextManager: ContextManager;
   loggerProvider?: LoggerProvider;
+  meterProvider?: MeterProvider;
   propagator?: TextMapPropagator;
 }

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

@@ -49,12 +49,22 @@ import { CompressionAlgorithm } from '@opentelemetry/otlp-exporter-base';
 import type {
   ConfigurationModel,
   LogRecordExporterModel,
+  InstrumentTypeConfigModel,
+  AggregationConfigModel,
+  PeriodicMetricReaderConfigModel,
 } from '@opentelemetry/configuration';
 import type {
+  AggregationOption,
   IMetricReader,
   PushMetricExporter,
+  ViewOptions,
+} from '@opentelemetry/sdk-metrics';
+import {
+  AggregationType,
+  ConsoleMetricExporter,
+  InstrumentType,
+  PeriodicExportingMetricReader,
 } from '@opentelemetry/sdk-metrics';
-import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
 import { OTLPMetricExporter as OTLPGrpcMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc';
 import { OTLPMetricExporter as OTLPHttpMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
 import { OTLPMetricExporter as OTLPProtoMetricExporter } from '@opentelemetry/exporter-metrics-otlp-proto';
@@ -480,6 +490,58 @@ export function getOtlpMetricExporterFromEnv(): PushMetricExporter {
   return new OTLPProtoMetricExporter();
 }
 
+export function getPeriodicMetricReaderFromConfiguration(
+  periodic: PeriodicMetricReaderConfigModel
+): IMetricReader | undefined {
+  if (periodic.exporter) {
+    let exporter;
+    if (periodic.exporter.otlp_http) {
+      const encoding = periodic.exporter.otlp_http.encoding;
+      if (encoding === 'json') {
+        exporter = new OTLPHttpMetricExporter({
+          compression:
+            periodic.exporter.otlp_http.compression === 'gzip'
+              ? CompressionAlgorithm.GZIP
+              : CompressionAlgorithm.NONE,
+        });
+      } else if (encoding === 'protobuf') {
+        exporter = new OTLPProtoMetricExporter({
+          compression:
+            periodic.exporter.otlp_http.compression === 'gzip'
+              ? CompressionAlgorithm.GZIP
+              : CompressionAlgorithm.NONE,
+        });
+      } else {
+        diag.warn(`Unsupported OTLP metrics encoding: ${encoding}.`);
+      }
+    }
+    if (periodic.exporter.otlp_grpc) {
+      exporter = new OTLPGrpcMetricExporter({
+        compression:
+          periodic.exporter.otlp_grpc.compression === 'gzip'
+            ? CompressionAlgorithm.GZIP
+            : CompressionAlgorithm.NONE,
+      });
+    }
+
+    if (exporter) {
+      // TODO(6425): add cardinality_limits
+      return new PeriodicExportingMetricReader({
+        exportIntervalMillis: periodic.interval ?? 60_000,
+        exportTimeoutMillis: periodic.timeout ?? 30_000,
+        exporter,
+      });
+    }
+    if (periodic.exporter.console) {
+      return new PeriodicExportingMetricReader({
+        exporter: new ConsoleMetricExporter(),
+      });
+    }
+  }
+  diag.warn(`Unsupported Metric Exporter.`);
+  return undefined;
+}
+
 /**
  * Get LoggerProviderConfig from environment variables.
  */
@@ -599,6 +661,157 @@ export function getLogRecordProcessorsFromConfiguration(
   return undefined;
 }
 
+export function getMeterReadersFromConfiguration(
+  config: ConfigurationModel
+): IMetricReader[] | undefined {
+  const metricReaders: IMetricReader[] = [];
+  config.meter_provider?.readers?.forEach(reader => {
+    if (reader.periodic) {
+      const periodicReader = getPeriodicMetricReaderFromConfiguration(
+        reader.periodic
+      );
+      if (periodicReader) {
+        metricReaders.push(periodicReader);
+      }
+    }
+  });
+  if (metricReaders.length > 0) {
+    return metricReaders;
+  }
+  return undefined;
+}
+
+export function getInstrumentType(
+  instrument: InstrumentTypeConfigModel
+): InstrumentType | undefined {
+  switch (instrument) {
+    case 'counter':
+      return InstrumentType.COUNTER;
+    case 'gauge':
+      return InstrumentType.GAUGE;
+    case 'histogram':
+      return InstrumentType.HISTOGRAM;
+    case 'observable_counter':
+      return InstrumentType.OBSERVABLE_COUNTER;
+    case 'observable_gauge':
+      return InstrumentType.OBSERVABLE_GAUGE;
+    case 'observable_up_down_counter':
+      return InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
+    case 'up_down_counter':
+      return InstrumentType.UP_DOWN_COUNTER;
+    default:
+      diag.warn(`Unsupported instrument type: ${instrument}`);
+      return undefined;
+  }
+}
+
+export function getAggregationType(
+  aggregation: AggregationConfigModel
+): AggregationOption | undefined {
+  if (aggregation.default) {
+    return {
+      type: AggregationType.DEFAULT,
+    };
+  }
+  if (aggregation.drop) {
+    return {
+      type: AggregationType.DROP,
+    };
+  }
+  if (aggregation.explicit_bucket_histogram) {
+    return {
+      type: AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
+      options: {
+        recordMinMax:
+          aggregation.explicit_bucket_histogram.record_min_max ?? true,
+        boundaries: aggregation.explicit_bucket_histogram.boundaries ?? [
+          0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500,
+          10000,
+        ],
+      },
+    };
+  }
+
+  if (aggregation.base2_exponential_bucket_histogram) {
+    return {
+      type: AggregationType.EXPONENTIAL_HISTOGRAM,
+      options: {
+        recordMinMax:
+          aggregation.base2_exponential_bucket_histogram.record_min_max ?? true,
+        maxSize: aggregation.base2_exponential_bucket_histogram.max_size,
+      },
+    };
+  }
+  if (aggregation.last_value) {
+    return {
+      type: AggregationType.LAST_VALUE,
+    };
+  }
+  if (aggregation.sum) {
+    return {
+      type: AggregationType.SUM,
+    };
+  }
+
+  diag.warn(`Unsupported aggregation type`);
+  return undefined;
+}
+
+export function getMeterViewsFromConfiguration(
+  config: ConfigurationModel
+): ViewOptions[] | undefined {
+  const metricViews: ViewOptions[] = [];
+  config.meter_provider?.views?.forEach(view => {
+    const viewOption: ViewOptions = {};
+    if (view.selector) {
+      if (view.selector.instrument_name) {
+        viewOption.instrumentName = view.selector.instrument_name;
+      }
+      if (view.selector.instrument_type) {
+        const instrumentType = getInstrumentType(view.selector.instrument_type);
+        if (instrumentType) {
+          viewOption.instrumentType = instrumentType;
+        }
+      }
+      if (view.selector.unit) {
+        viewOption.instrumentUnit = view.selector.unit;
+      }
+      if (view.selector.meter_name) {
+        viewOption.meterName = view.selector.meter_name;
+      }
+      if (view.selector.meter_version) {
+        viewOption.meterVersion = view.selector.meter_version;
+      }
+      if (view.selector.meter_schema_url) {
+        viewOption.meterSchemaUrl = view.selector.meter_schema_url;
+      }
+    }
+    if (view.stream) {
+      viewOption.name = view.stream.name ?? view.selector?.instrument_name;
+      viewOption.aggregationCardinalityLimit =
+        view.stream.aggregation_cardinality_limit ?? 2_000;
+      if (view.stream.description) {
+        viewOption.description = view.stream.description;
+      }
+      if (view.stream.aggregation) {
+        const aggregationType = getAggregationType(view.stream.aggregation);
+        if (aggregationType) {
+          viewOption.aggregation = aggregationType;
+        }
+      }
+      // TODO(6427): add support for view.stream.attribute_keys and correspondent attributes processor configuration
+    }
+
+    if (Object.keys(viewOption).length > 0) {
+      metricViews.push(viewOption);
+    }
+  });
+  if (metricViews.length > 0) {
+    return metricViews;
+  }
+  return undefined;
+}
+
 export function getInstanceID(config: ConfigurationModel): string | undefined {
   if (config.resource?.attributes) {
     for (let i = 0; i < config.resource.attributes.length; i++) {