@opentelemetry/sdk-node 0.212.0 → 0.214.0

package/build/src/types.d.ts

@@ -1,10 +1,11 @@
 import type { ContextManager } from '@opentelemetry/api';
-import { TextMapPropagator } from '@opentelemetry/api';
-import { Instrumentation } from '@opentelemetry/instrumentation';
-import { Resource, ResourceDetector } from '@opentelemetry/resources';
-import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
-import { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';
-import { Sampler, SpanExporter, SpanLimits, SpanProcessor, IdGenerator } from '@opentelemetry/sdk-trace-base';
+import type { TextMapPropagator } from '@opentelemetry/api';
+import type { Instrumentation } from '@opentelemetry/instrumentation';
+import type { Resource, ResourceDetector } from '@opentelemetry/resources';
+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, SpanExporter, SpanLimits, SpanProcessor, IdGenerator } from '@opentelemetry/sdk-trace-base';
 export interface NodeSDKConfiguration {
     autoDetectResources: boolean;
     contextManager: ContextManager;
@@ -33,6 +34,13 @@ export interface NodeSDKConfiguration {
  */
 export interface SDKOptions {
     instrumentations?: (Instrumentation | Instrumentation[])[];
+    resourceDetectors?: ResourceDetector[];
     textMapPropagator?: TextMapPropagator | null;
 }
+export interface SDKComponents {
+    contextManager: ContextManager;
+    loggerProvider?: LoggerProvider;
+    meterProvider?: MeterProvider;
+    propagator?: TextMapPropagator;
+}
 //# sourceMappingURL=types.d.ts.map

package/build/src/types.js

@@ -1,18 +1,7 @@
 "use strict";
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/build/src/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { ContextManager } from '@opentelemetry/api';\nimport { TextMapPropagator } from '@opentelemetry/api';\nimport { Instrumentation } from '@opentelemetry/instrumentation';\nimport { Resource, ResourceDetector } from '@opentelemetry/resources';\nimport { LogRecordProcessor } from '@opentelemetry/sdk-logs';\nimport { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';\nimport {\n  Sampler,\n  SpanExporter,\n  SpanLimits,\n  SpanProcessor,\n  IdGenerator,\n} from '@opentelemetry/sdk-trace-base';\n\nexport interface NodeSDKConfiguration {\n  autoDetectResources: boolean;\n  contextManager: ContextManager;\n  textMapPropagator: TextMapPropagator | null;\n  /** @deprecated use logRecordProcessors instead*/\n  logRecordProcessor: LogRecordProcessor;\n  logRecordProcessors?: LogRecordProcessor[];\n  /** @deprecated use metricReaders instead*/\n  metricReader: IMetricReader;\n  metricReaders?: IMetricReader[];\n  views: ViewOptions[];\n  instrumentations: (Instrumentation | Instrumentation[])[];\n  resource: Resource;\n  resourceDetectors: Array<ResourceDetector>;\n  sampler: Sampler;\n  serviceName?: string;\n  /** @deprecated use spanProcessors instead*/\n  spanProcessor?: SpanProcessor;\n  spanProcessors?: SpanProcessor[];\n  traceExporter: SpanExporter;\n  spanLimits: SpanLimits;\n  idGenerator: IdGenerator;\n}\n/**\n * @experimental Options for new experimental SDK setup\n */\nexport interface SDKOptions {\n  instrumentations?: (Instrumentation | Instrumentation[])[];\n  textMapPropagator?: TextMapPropagator | null;\n}\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { ContextManager } from '@opentelemetry/api';\nimport type { TextMapPropagator } from '@opentelemetry/api';\nimport type { Instrumentation } from '@opentelemetry/instrumentation';\nimport type { Resource, ResourceDetector } from '@opentelemetry/resources';\nimport type {\n  LoggerProvider,\n  LogRecordProcessor,\n} from '@opentelemetry/sdk-logs';\nimport type { MeterProvider } from '@opentelemetry/sdk-metrics';\nimport type { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';\nimport type {\n  Sampler,\n  SpanExporter,\n  SpanLimits,\n  SpanProcessor,\n  IdGenerator,\n} from '@opentelemetry/sdk-trace-base';\n\nexport interface NodeSDKConfiguration {\n  autoDetectResources: boolean;\n  contextManager: ContextManager;\n  textMapPropagator: TextMapPropagator | null;\n  /** @deprecated use logRecordProcessors instead*/\n  logRecordProcessor: LogRecordProcessor;\n  logRecordProcessors?: LogRecordProcessor[];\n  /** @deprecated use metricReaders instead*/\n  metricReader: IMetricReader;\n  metricReaders?: IMetricReader[];\n  views: ViewOptions[];\n  instrumentations: (Instrumentation | Instrumentation[])[];\n  resource: Resource;\n  resourceDetectors: Array<ResourceDetector>;\n  sampler: Sampler;\n  serviceName?: string;\n  /** @deprecated use spanProcessors instead*/\n  spanProcessor?: SpanProcessor;\n  spanProcessors?: SpanProcessor[];\n  traceExporter: SpanExporter;\n  spanLimits: SpanLimits;\n  idGenerator: IdGenerator;\n}\n/**\n * @experimental Options for new experimental SDK setup\n */\nexport interface SDKOptions {\n  instrumentations?: (Instrumentation | Instrumentation[])[];\n  resourceDetectors?: ResourceDetector[];\n  textMapPropagator?: TextMapPropagator | null;\n}\n\nexport interface SDKComponents {\n  contextManager: ContextManager;\n  loggerProvider?: LoggerProvider;\n  meterProvider?: MeterProvider;\n  propagator?: TextMapPropagator;\n}\n"]}

package/build/src/utils.d.ts

@@ -1,10 +1,14 @@
-import { ContextManager, TextMapPropagator } from '@opentelemetry/api';
-import { ResourceDetector } from '@opentelemetry/resources';
-import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { ConfigurationModel } from '@opentelemetry/configuration';
-import { IMetricReader, PushMetricExporter } from '@opentelemetry/sdk-metrics';
-import { BatchLogRecordProcessor, BufferConfig, LogRecordExporter, LoggerProviderConfig } from '@opentelemetry/sdk-logs';
+import type { ContextManager, TextMapPropagator } from '@opentelemetry/api';
+import type { Resource, ResourceDetector } from '@opentelemetry/resources';
+import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import type { ConfigurationModel, LogRecordExporterConfigModel, InstrumentTypeConfigModel, AggregationConfigModel, PeriodicMetricReaderConfigModel } from '@opentelemetry/configuration';
+import type { AggregationOption, IMetricReader, PushMetricExporter, ViewOptions } from '@opentelemetry/sdk-metrics';
+import { InstrumentType } from '@opentelemetry/sdk-metrics';
+import type { BufferConfig, LogRecordExporter, LoggerProviderConfig, LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+export declare function getResourceFromConfiguration(config: ConfigurationModel): Resource | undefined;
 export declare function getResourceDetectorsFromEnv(): Array<ResourceDetector>;
+export declare function getResourceDetectorsFromConfiguration(config: ConfigurationModel): Array<ResourceDetector>;
 export declare function getOtlpProtocolFromEnv(): string;
 export declare function getSpanProcessorsFromEnv(): SpanProcessor[];
 /**
@@ -16,12 +20,12 @@ export declare function getPropagatorFromEnv(): TextMapPropagator | null | undef
  */
 export declare function getPropagatorFromConfiguration(config: ConfigurationModel): TextMapPropagator | null | undefined;
 export declare function setupContextManager(contextManager: ContextManager | null | undefined): void;
-export declare function setupDefaultContextManager(): void;
 export declare function setupPropagator(propagator: TextMapPropagator | null | undefined): void;
 export declare function getKeyListFromObjectArray(obj: object[] | undefined): string[] | undefined;
 export declare function getNonNegativeNumberFromEnv(envVarName: string): number | undefined;
 export declare function getPeriodicExportingMetricReaderFromEnv(exporter: PushMetricExporter): IMetricReader;
 export declare function getOtlpMetricExporterFromEnv(): PushMetricExporter;
+export declare function getPeriodicMetricReaderFromConfiguration(periodic: PeriodicMetricReaderConfigModel): IMetricReader | undefined;
 /**
  * Get LoggerProviderConfig from environment variables.
  */
@@ -31,4 +35,11 @@ export declare function getLoggerProviderConfigFromEnv(): LoggerProviderConfig;
  */
 export declare function getBatchLogRecordProcessorConfigFromEnv(): BufferConfig;
 export declare function getBatchLogRecordProcessorFromEnv(exporter: LogRecordExporter): BatchLogRecordProcessor;
+export declare function getLogRecordExporter(exporter: LogRecordExporterConfigModel): LogRecordExporter | undefined;
+export declare function getLogRecordProcessorsFromConfiguration(config: ConfigurationModel): LogRecordProcessor[] | undefined;
+export declare function getMeterReadersFromConfiguration(config: ConfigurationModel): IMetricReader[] | undefined;
+export declare function getInstrumentType(instrument: InstrumentTypeConfigModel): InstrumentType | undefined;
+export declare function getAggregationType(aggregation: AggregationConfigModel): AggregationOption | undefined;
+export declare function getMeterViewsFromConfiguration(config: ConfigurationModel): ViewOptions[] | undefined;
+export declare function getInstanceID(config: ConfigurationModel): string | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/build/src/utils.js

@@ -1,21 +1,10 @@
 "use strict";
 /*
  * Copyright The OpenTelemetry Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * SPDX-License-Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBatchLogRecordProcessorFromEnv = exports.getBatchLogRecordProcessorConfigFromEnv = exports.getLoggerProviderConfigFromEnv = exports.getOtlpMetricExporterFromEnv = exports.getPeriodicExportingMetricReaderFromEnv = exports.getNonNegativeNumberFromEnv = exports.getKeyListFromObjectArray = exports.setupPropagator = exports.setupDefaultContextManager = exports.setupContextManager = exports.getPropagatorFromConfiguration = exports.getPropagatorFromEnv = exports.getSpanProcessorsFromEnv = exports.getOtlpProtocolFromEnv = exports.getResourceDetectorsFromEnv = void 0;
+exports.getInstanceID = exports.getMeterViewsFromConfiguration = exports.getAggregationType = exports.getInstrumentType = exports.getMeterReadersFromConfiguration = exports.getLogRecordProcessorsFromConfiguration = exports.getLogRecordExporter = exports.getBatchLogRecordProcessorFromEnv = exports.getBatchLogRecordProcessorConfigFromEnv = exports.getLoggerProviderConfigFromEnv = exports.getPeriodicMetricReaderFromConfiguration = exports.getOtlpMetricExporterFromEnv = exports.getPeriodicExportingMetricReaderFromEnv = exports.getNonNegativeNumberFromEnv = exports.getKeyListFromObjectArray = exports.setupPropagator = exports.setupContextManager = exports.getPropagatorFromConfiguration = exports.getPropagatorFromEnv = exports.getSpanProcessorsFromEnv = exports.getOtlpProtocolFromEnv = exports.getResourceDetectorsFromConfiguration = exports.getResourceDetectorsFromEnv = exports.getResourceFromConfiguration = void 0;
 const api_1 = require("@opentelemetry/api");
 const core_1 = require("@opentelemetry/core");
 const exporter_trace_otlp_proto_1 = require("@opentelemetry/exporter-trace-otlp-proto");
@@ -27,6 +16,10 @@ const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 const propagator_b3_1 = require("@opentelemetry/propagator-b3");
 const propagator_jaeger_1 = require("@opentelemetry/propagator-jaeger");
 const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const exporter_logs_otlp_grpc_1 = require("@opentelemetry/exporter-logs-otlp-grpc");
+const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
+const otlp_exporter_base_1 = require("@opentelemetry/otlp-exporter-base");
 const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
 const exporter_metrics_otlp_grpc_1 = require("@opentelemetry/exporter-metrics-otlp-grpc");
 const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
@@ -37,6 +30,20 @@ const RESOURCE_DETECTOR_HOST = 'host';
 const RESOURCE_DETECTOR_OS = 'os';
 const RESOURCE_DETECTOR_PROCESS = 'process';
 const RESOURCE_DETECTOR_SERVICE_INSTANCE_ID = 'serviceinstance';
+function getResourceFromConfiguration(config) {
+    if (config.resource && config.resource.attributes) {
+        const attr = {};
+        for (let i = 0; i < config.resource.attributes.length; i++) {
+            const a = config.resource.attributes[i];
+            attr[a.name] = a.value;
+        }
+        return (0, resources_1.resourceFromAttributes)(attr, {
+            schemaUrl: config.resource.schema_url,
+        });
+    }
+    return undefined;
+}
+exports.getResourceFromConfiguration = getResourceFromConfiguration;
 function getResourceDetectorsFromEnv() {
     // When updating this list, make sure to also update the section `resourceDetectors` on README.
     const resourceDetectors = new Map([
@@ -62,6 +69,24 @@ function getResourceDetectorsFromEnv() {
     });
 }
 exports.getResourceDetectorsFromEnv = getResourceDetectorsFromEnv;
+function getResourceDetectorsFromConfiguration(config) {
+    const detectors = config.resource?.['detection/development']?.detectors ?? [];
+    return detectors.flatMap(detector => {
+        const result = [];
+        if (detector.host != null)
+            result.push(resources_1.hostDetector);
+        if (detector.os != null)
+            result.push(resources_1.osDetector);
+        if (detector.process != null)
+            result.push(resources_1.processDetector);
+        if (detector.service != null)
+            result.push(resources_1.serviceInstanceIdDetector);
+        if (detector.env != null)
+            result.push(resources_1.envDetector);
+        return result;
+    });
+}
+exports.getResourceDetectorsFromConfiguration = getResourceDetectorsFromConfiguration;
 function getOtlpProtocolFromEnv() {
     return ((0, core_1.getStringFromEnv)('OTEL_EXPORTER_OTLP_TRACES_PROTOCOL') ??
         (0, core_1.getStringFromEnv)('OTEL_EXPORTER_OTLP_PROTOCOL') ??
@@ -242,12 +267,6 @@ function setupContextManager(contextManager) {
     api_1.context.setGlobalContextManager(contextManager);
 }
 exports.setupContextManager = setupContextManager;
-function setupDefaultContextManager() {
-    const defaultContextManager = new context_async_hooks_1.AsyncLocalStorageContextManager();
-    defaultContextManager.enable();
-    api_1.context.setGlobalContextManager(defaultContextManager);
-}
-exports.setupDefaultContextManager = setupDefaultContextManager;
 function setupPropagator(propagator) {
     // null means 'do not register'
     if (propagator === null) {
@@ -334,6 +353,54 @@ function getOtlpMetricExporterFromEnv() {
     return new exporter_metrics_otlp_proto_1.OTLPMetricExporter();
 }
 exports.getOtlpMetricExporterFromEnv = getOtlpMetricExporterFromEnv;
+function getPeriodicMetricReaderFromConfiguration(periodic) {
+    if (periodic.exporter) {
+        let exporter;
+        if (periodic.exporter.otlp_http) {
+            const encoding = periodic.exporter.otlp_http.encoding;
+            if (encoding === 'json') {
+                exporter = new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+                    compression: periodic.exporter.otlp_http.compression === 'gzip'
+                        ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                        : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+                });
+            }
+            else if (encoding === 'protobuf') {
+                exporter = new exporter_metrics_otlp_proto_1.OTLPMetricExporter({
+                    compression: periodic.exporter.otlp_http.compression === 'gzip'
+                        ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                        : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+                });
+            }
+            else {
+                api_1.diag.warn(`Unsupported OTLP metrics encoding: ${encoding}.`);
+            }
+        }
+        if (periodic.exporter.otlp_grpc) {
+            exporter = new exporter_metrics_otlp_grpc_1.OTLPMetricExporter({
+                compression: periodic.exporter.otlp_grpc.compression === 'gzip'
+                    ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                    : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+            });
+        }
+        if (exporter) {
+            // TODO(6425): add cardinality_limits
+            return new sdk_metrics_1.PeriodicExportingMetricReader({
+                exportIntervalMillis: periodic.interval ?? 60000,
+                exportTimeoutMillis: periodic.timeout ?? 30000,
+                exporter,
+            });
+        }
+        if (periodic.exporter.console) {
+            return new sdk_metrics_1.PeriodicExportingMetricReader({
+                exporter: new sdk_metrics_1.ConsoleMetricExporter(),
+            });
+        }
+    }
+    api_1.diag.warn(`Unsupported Metric Exporter.`);
+    return undefined;
+}
+exports.getPeriodicMetricReaderFromConfiguration = getPeriodicMetricReaderFromConfiguration;
 /**
  * Get LoggerProviderConfig from environment variables.
  */
@@ -363,4 +430,217 @@ function getBatchLogRecordProcessorFromEnv(exporter) {
     return new sdk_logs_1.BatchLogRecordProcessor(exporter, getBatchLogRecordProcessorConfigFromEnv());
 }
 exports.getBatchLogRecordProcessorFromEnv = getBatchLogRecordProcessorFromEnv;
+function getLogRecordExporter(exporter) {
+    if (exporter.otlp_http) {
+        const encoding = exporter.otlp_http.encoding;
+        if (encoding === 'json') {
+            return new exporter_logs_otlp_http_1.OTLPLogExporter({
+                compression: exporter.otlp_http.compression === 'gzip'
+                    ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                    : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+            });
+        }
+        if (encoding === 'protobuf') {
+            return new exporter_logs_otlp_proto_1.OTLPLogExporter({
+                compression: exporter.otlp_http.compression === 'gzip'
+                    ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                    : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+            });
+        }
+        api_1.diag.warn(`Unsupported OTLP logs encoding: ${encoding}. Using http/protobuf.`);
+        return new exporter_logs_otlp_proto_1.OTLPLogExporter({
+            compression: exporter.otlp_http.compression === 'gzip'
+                ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+        });
+    }
+    else if (exporter.otlp_grpc) {
+        return new exporter_logs_otlp_grpc_1.OTLPLogExporter({
+            compression: exporter.otlp_grpc.compression === 'gzip'
+                ? otlp_exporter_base_1.CompressionAlgorithm.GZIP
+                : otlp_exporter_base_1.CompressionAlgorithm.NONE,
+        });
+    }
+    else if (exporter.console) {
+        return new sdk_logs_1.ConsoleLogRecordExporter();
+    }
+    api_1.diag.warn(`Unsupported Exporter value. No Log Record Exporter registered`);
+    return undefined;
+}
+exports.getLogRecordExporter = getLogRecordExporter;
+function getLogRecordProcessorsFromConfiguration(config) {
+    const logRecordProcessors = [];
+    config.logger_provider?.processors?.forEach(processor => {
+        if (processor.batch) {
+            const exporter = getLogRecordExporter(processor.batch.exporter);
+            if (exporter) {
+                logRecordProcessors.push(new sdk_logs_1.BatchLogRecordProcessor(exporter, {
+                    maxQueueSize: processor.batch.max_queue_size,
+                    maxExportBatchSize: processor.batch.max_export_batch_size,
+                    scheduledDelayMillis: processor.batch.schedule_delay,
+                    exportTimeoutMillis: processor.batch.export_timeout,
+                }));
+            }
+        }
+        if (processor.simple) {
+            const exporter = getLogRecordExporter(processor.simple.exporter);
+            if (exporter) {
+                logRecordProcessors.push(new sdk_logs_1.SimpleLogRecordProcessor(exporter));
+            }
+        }
+    });
+    if (logRecordProcessors.length > 0) {
+        return logRecordProcessors;
+    }
+    return undefined;
+}
+exports.getLogRecordProcessorsFromConfiguration = getLogRecordProcessorsFromConfiguration;
+function getMeterReadersFromConfiguration(config) {
+    const metricReaders = [];
+    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;
+}
+exports.getMeterReadersFromConfiguration = getMeterReadersFromConfiguration;
+function getInstrumentType(instrument) {
+    switch (instrument) {
+        case 'counter':
+            return sdk_metrics_1.InstrumentType.COUNTER;
+        case 'gauge':
+            return sdk_metrics_1.InstrumentType.GAUGE;
+        case 'histogram':
+            return sdk_metrics_1.InstrumentType.HISTOGRAM;
+        case 'observable_counter':
+            return sdk_metrics_1.InstrumentType.OBSERVABLE_COUNTER;
+        case 'observable_gauge':
+            return sdk_metrics_1.InstrumentType.OBSERVABLE_GAUGE;
+        case 'observable_up_down_counter':
+            return sdk_metrics_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
+        case 'up_down_counter':
+            return sdk_metrics_1.InstrumentType.UP_DOWN_COUNTER;
+        default:
+            api_1.diag.warn(`Unsupported instrument type: ${instrument}`);
+            return undefined;
+    }
+}
+exports.getInstrumentType = getInstrumentType;
+function getAggregationType(aggregation) {
+    if (aggregation.default) {
+        return {
+            type: sdk_metrics_1.AggregationType.DEFAULT,
+        };
+    }
+    if (aggregation.drop) {
+        return {
+            type: sdk_metrics_1.AggregationType.DROP,
+        };
+    }
+    if (aggregation.explicit_bucket_histogram) {
+        return {
+            type: sdk_metrics_1.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: sdk_metrics_1.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: sdk_metrics_1.AggregationType.LAST_VALUE,
+        };
+    }
+    if (aggregation.sum) {
+        return {
+            type: sdk_metrics_1.AggregationType.SUM,
+        };
+    }
+    api_1.diag.warn(`Unsupported aggregation type`);
+    return undefined;
+}
+exports.getAggregationType = getAggregationType;
+function getMeterViewsFromConfiguration(config) {
+    const metricViews = [];
+    config.meter_provider?.views?.forEach(view => {
+        const viewOption = {};
+        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 ?? 2000;
+            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;
+}
+exports.getMeterViewsFromConfiguration = getMeterViewsFromConfiguration;
+function getInstanceID(config) {
+    if (config.resource?.attributes) {
+        for (let i = 0; i < config.resource.attributes.length; i++) {
+            const element = config.resource.attributes[i];
+            if (element.name === 'service.instance.id') {
+                return element.value?.toString();
+            }
+        }
+    }
+    return undefined;
+}
+exports.getInstanceID = getInstanceID;
 //# sourceMappingURL=utils.js.map