Update test framework: fix run_tests.py to support all test files, add auto-import-check for test files

node_modules/@opentelemetry/sdk-node/build/src/index.d.ts

@@ -0,0 +1,11 @@
+export * as api from '@opentelemetry/api';
+export * as contextBase from '@opentelemetry/api';
+export * as core from '@opentelemetry/core';
+export * as logs from '@opentelemetry/sdk-logs';
+export * as metrics from '@opentelemetry/sdk-metrics';
+export * as node from '@opentelemetry/sdk-trace-node';
+export * as resources from '@opentelemetry/resources';
+export * as tracing from '@opentelemetry/sdk-trace-base';
+export { LoggerProviderConfig, MeterProviderConfig, NodeSDK } from './sdk';
+export { NodeSDKConfiguration } from './types';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/sdk-node/build/src/index.js

@@ -0,0 +1,32 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSDK = exports.tracing = exports.resources = exports.node = exports.metrics = exports.logs = exports.core = exports.contextBase = exports.api = void 0;
+/* eslint no-restricted-syntax: ["warn", "ExportAllDeclaration"] --
+ * TODO: Replace wildcard export with named exports before next major version
+ */
+exports.api = require("@opentelemetry/api");
+exports.contextBase = require("@opentelemetry/api");
+exports.core = require("@opentelemetry/core");
+exports.logs = require("@opentelemetry/sdk-logs");
+exports.metrics = require("@opentelemetry/sdk-metrics");
+exports.node = require("@opentelemetry/sdk-trace-node");
+exports.resources = require("@opentelemetry/resources");
+exports.tracing = require("@opentelemetry/sdk-trace-base");
+var sdk_1 = require("./sdk");
+Object.defineProperty(exports, "NodeSDK", { enumerable: true, get: function () { return sdk_1.NodeSDK; } });
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/sdk-node/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH;;GAEG;AACH,4CAA0C;AAC1C,oDAAkD;AAClD,8CAA4C;AAC5C,kDAAgD;AAChD,wDAAsD;AACtD,wDAAsD;AACtD,wDAAsD;AACtD,2DAAyD;AACzD,6BAA2E;AAAvB,8FAAA,OAAO,OAAA","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\n/* eslint no-restricted-syntax: [\"warn\", \"ExportAllDeclaration\"] --\n * TODO: Replace wildcard export with named exports before next major version\n */\nexport * as api from '@opentelemetry/api';\nexport * as contextBase from '@opentelemetry/api';\nexport * as core from '@opentelemetry/core';\nexport * as logs from '@opentelemetry/sdk-logs';\nexport * as metrics from '@opentelemetry/sdk-metrics';\nexport * as node from '@opentelemetry/sdk-trace-node';\nexport * as resources from '@opentelemetry/resources';\nexport * as tracing from '@opentelemetry/sdk-trace-base';\nexport { LoggerProviderConfig, MeterProviderConfig, NodeSDK } from './sdk';\nexport { NodeSDKConfiguration } from './types';\n"]}

node_modules/@opentelemetry/sdk-node/build/src/sdk.d.ts

@@ -0,0 +1,46 @@
+import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';
+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?: IMetricReader;
+    /**
+     * List of {@link ViewOptions}s that should be passed to the MeterProvider
+     */
+    views?: ViewOptions[];
+};
+export type LoggerProviderConfig = {
+    /**
+     * Reference to the LoggerRecordProcessor instance by the NodeSDK
+     */
+    logRecordProcessors: LogRecordProcessor[];
+};
+export declare class NodeSDK {
+    private _tracerProviderConfig?;
+    private _loggerProviderConfig?;
+    private _meterProviderConfig?;
+    private _instrumentations;
+    private _resource;
+    private _resourceDetectors;
+    private _autoDetectResources;
+    private _tracerProvider?;
+    private _loggerProvider?;
+    private _meterProvider?;
+    private _serviceName?;
+    private _configuration?;
+    private _disabled?;
+    /**
+     * Create a new NodeJS SDK instance
+     */
+    constructor(configuration?: Partial<NodeSDKConfiguration>);
+    /**
+     * Call this method to construct SDK components and register them with the OpenTelemetry API.
+     */
+    start(): void;
+    shutdown(): Promise<void>;
+    private configureLoggerProviderFromEnv;
+}
+//# sourceMappingURL=sdk.d.ts.map

node_modules/@opentelemetry/sdk-node/build/src/sdk.js

@@ -0,0 +1,358 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSDK = void 0;
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+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 exporter_metrics_otlp_grpc_1 = require("@opentelemetry/exporter-metrics-otlp-grpc");
+const exporter_metrics_otlp_proto_1 = require("@opentelemetry/exporter-metrics-otlp-proto");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_prometheus_1 = require("@opentelemetry/exporter-prometheus");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const core_1 = require("@opentelemetry/core");
+const utils_1 = require("./utils");
+/**
+ * @Returns param value, if set else returns the default value
+ */
+function getValueInMillis(envName, defaultValue) {
+    return parseInt(process.env[envName] || '') || defaultValue;
+}
+/**
+ *
+ * @returns MetricReader[] if appropriate environment variables are configured
+ */
+function configureMetricProviderFromEnv() {
+    const metricReaders = [];
+    const metricsExporterList = process.env.OTEL_METRICS_EXPORTER?.trim();
+    if (!metricsExporterList) {
+        return metricReaders;
+    }
+    const enabledExporters = (0, utils_1.filterBlanksAndNulls)(metricsExporterList.split(','));
+    if (enabledExporters.length === 0) {
+        api_1.diag.debug('OTEL_METRICS_EXPORTER is empty. Using default otlp exporter.');
+    }
+    if (enabledExporters.includes('none')) {
+        api_1.diag.info(`OTEL_METRICS_EXPORTER contains "none". Metric provider will not be initialized.`);
+        return metricReaders;
+    }
+    enabledExporters.forEach(exporter => {
+        if (exporter === 'otlp') {
+            const protocol = process.env.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL?.trim() ||
+                process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+            const exportIntervalMillis = getValueInMillis('OTEL_METRIC_EXPORT_INTERVAL', 60000);
+            const exportTimeoutMillis = getValueInMillis('OTEL_METRIC_EXPORT_TIMEOUT', 30000);
+            switch (protocol) {
+                case 'grpc':
+                    metricReaders.push(new sdk_metrics_1.PeriodicExportingMetricReader({
+                        exporter: new exporter_metrics_otlp_grpc_1.OTLPMetricExporter(),
+                        exportIntervalMillis: exportIntervalMillis,
+                        exportTimeoutMillis: exportTimeoutMillis,
+                    }));
+                    break;
+                case 'http/json':
+                    metricReaders.push(new sdk_metrics_1.PeriodicExportingMetricReader({
+                        exporter: new exporter_metrics_otlp_http_1.OTLPMetricExporter(),
+                        exportIntervalMillis: exportIntervalMillis,
+                        exportTimeoutMillis: exportTimeoutMillis,
+                    }));
+                    break;
+                case 'http/protobuf':
+                    metricReaders.push(new sdk_metrics_1.PeriodicExportingMetricReader({
+                        exporter: new exporter_metrics_otlp_proto_1.OTLPMetricExporter(),
+                        exportIntervalMillis: exportIntervalMillis,
+                        exportTimeoutMillis: exportTimeoutMillis,
+                    }));
+                    break;
+                default:
+                    api_1.diag.warn(`Unsupported OTLP metrics protocol: "${protocol}". Using http/protobuf.`);
+                    metricReaders.push(new sdk_metrics_1.PeriodicExportingMetricReader({
+                        exporter: new exporter_metrics_otlp_proto_1.OTLPMetricExporter(),
+                        exportIntervalMillis: exportIntervalMillis,
+                        exportTimeoutMillis: exportTimeoutMillis,
+                    }));
+            }
+        }
+        else if (exporter === 'console') {
+            metricReaders.push(new sdk_metrics_1.PeriodicExportingMetricReader({
+                exporter: new sdk_metrics_1.ConsoleMetricExporter(),
+            }));
+        }
+        else if (exporter === 'prometheus') {
+            metricReaders.push(new exporter_prometheus_1.PrometheusExporter());
+        }
+        else {
+            api_1.diag.warn(`Unsupported OTEL_METRICS_EXPORTER value: "${exporter}". Supported values are: otlp, console, prometheus, none.`);
+        }
+    });
+    return metricReaders;
+}
+class NodeSDK {
+    _tracerProviderConfig;
+    _loggerProviderConfig;
+    _meterProviderConfig;
+    _instrumentations;
+    _resource;
+    _resourceDetectors;
+    _autoDetectResources;
+    _tracerProvider;
+    _loggerProvider;
+    _meterProvider;
+    _serviceName;
+    _configuration;
+    _disabled;
+    /**
+     * Create a new NodeJS SDK instance
+     */
+    constructor(configuration = {}) {
+        if ((0, core_1.getBooleanFromEnv)('OTEL_SDK_DISABLED')) {
+            this._disabled = true;
+            // Functions with possible side-effects are set
+            // to no-op via the _disabled flag
+        }
+        const logLevel = (0, core_1.getStringFromEnv)('OTEL_LOG_LEVEL');
+        if (logLevel != null) {
+            api_1.diag.setLogger(new api_1.DiagConsoleLogger(), {
+                logLevel: (0, core_1.diagLogLevelFromString)(logLevel),
+            });
+        }
+        this._configuration = configuration;
+        this._resource = configuration.resource ?? (0, resources_1.defaultResource)();
+        this._autoDetectResources = configuration.autoDetectResources ?? true;
+        if (!this._autoDetectResources) {
+            this._resourceDetectors = [];
+        }
+        else if (configuration.resourceDetectors != null) {
+            this._resourceDetectors = configuration.resourceDetectors;
+        }
+        else if (process.env.OTEL_NODE_RESOURCE_DETECTORS != null) {
+            this._resourceDetectors = (0, utils_1.getResourceDetectorsFromEnv)();
+        }
+        else {
+            this._resourceDetectors = [resources_1.envDetector, resources_1.processDetector, resources_1.hostDetector];
+        }
+        this._serviceName = configuration.serviceName;
+        // If a tracer provider can be created from manual configuration, create it
+        if (configuration.traceExporter ||
+            configuration.spanProcessor ||
+            configuration.spanProcessors) {
+            const tracerProviderConfig = {};
+            if (configuration.sampler) {
+                tracerProviderConfig.sampler = configuration.sampler;
+            }
+            if (configuration.spanLimits) {
+                tracerProviderConfig.spanLimits = configuration.spanLimits;
+            }
+            if (configuration.idGenerator) {
+                tracerProviderConfig.idGenerator = configuration.idGenerator;
+            }
+            if (configuration.spanProcessor) {
+                api_1.diag.warn("The 'spanProcessor' option is deprecated. Please use 'spanProcessors' instead.");
+            }
+            const spanProcessor = configuration.spanProcessor ??
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                new sdk_trace_base_1.BatchSpanProcessor(configuration.traceExporter);
+            const spanProcessors = configuration.spanProcessors ?? [spanProcessor];
+            this._tracerProviderConfig = {
+                tracerConfig: tracerProviderConfig,
+                spanProcessors,
+                contextManager: configuration.contextManager,
+                textMapPropagator: configuration.textMapPropagator,
+            };
+        }
+        if (configuration.logRecordProcessors) {
+            this._loggerProviderConfig = {
+                logRecordProcessors: configuration.logRecordProcessors,
+            };
+        }
+        else if (configuration.logRecordProcessor) {
+            this._loggerProviderConfig = {
+                logRecordProcessors: [configuration.logRecordProcessor],
+            };
+            api_1.diag.warn("The 'logRecordProcessor' option is deprecated. Please use 'logRecordProcessors' instead.");
+        }
+        else {
+            this.configureLoggerProviderFromEnv();
+        }
+        if (configuration.metricReader || configuration.views) {
+            const meterProviderConfig = {};
+            if (configuration.metricReader) {
+                meterProviderConfig.reader = configuration.metricReader;
+            }
+            if (configuration.views) {
+                meterProviderConfig.views = configuration.views;
+            }
+            this._meterProviderConfig = meterProviderConfig;
+        }
+        this._instrumentations = configuration.instrumentations?.flat() ?? [];
+    }
+    /**
+     * Call this method to construct SDK components and register them with the OpenTelemetry API.
+     */
+    start() {
+        if (this._disabled) {
+            return;
+        }
+        (0, instrumentation_1.registerInstrumentations)({
+            instrumentations: this._instrumentations,
+        });
+        if (this._autoDetectResources) {
+            const internalConfig = {
+                detectors: this._resourceDetectors,
+            };
+            this._resource = this._resource.merge((0, resources_1.detectResources)(internalConfig));
+        }
+        this._resource =
+            this._serviceName === undefined
+                ? this._resource
+                : this._resource.merge((0, resources_1.resourceFromAttributes)({
+                    [semantic_conventions_1.ATTR_SERVICE_NAME]: this._serviceName,
+                }));
+        const spanProcessors = this._tracerProviderConfig
+            ? this._tracerProviderConfig.spanProcessors
+            : (0, utils_1.getSpanProcessorsFromEnv)();
+        this._tracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+            ...this._configuration,
+            resource: this._resource,
+            spanProcessors,
+        });
+        // Only register if there is a span processor
+        if (spanProcessors.length > 0) {
+            this._tracerProvider.register({
+                contextManager: this._tracerProviderConfig?.contextManager ??
+                    // _tracerProviderConfig may be undefined if trace-specific settings are not provided - fall back to raw config
+                    this._configuration?.contextManager,
+                propagator: this._tracerProviderConfig?.textMapPropagator ??
+                    (0, utils_1.getPropagatorFromEnv)(),
+            });
+        }
+        if (this._loggerProviderConfig) {
+            const loggerProvider = new sdk_logs_1.LoggerProvider({
+                resource: this._resource,
+            });
+            for (const logRecordProcessor of this._loggerProviderConfig
+                .logRecordProcessors) {
+                loggerProvider.addLogRecordProcessor(logRecordProcessor);
+            }
+            this._loggerProvider = loggerProvider;
+            api_logs_1.logs.setGlobalLoggerProvider(loggerProvider);
+        }
+        const metricReadersFromEnv = configureMetricProviderFromEnv();
+        if (this._meterProviderConfig || metricReadersFromEnv.length > 0) {
+            const readers = [];
+            if (this._meterProviderConfig?.reader) {
+                readers.push(this._meterProviderConfig.reader);
+            }
+            if (readers.length === 0) {
+                metricReadersFromEnv.forEach((r) => readers.push(r));
+            }
+            const meterProvider = new sdk_metrics_1.MeterProvider({
+                resource: this._resource,
+                views: this._meterProviderConfig?.views ?? [],
+                readers: readers,
+            });
+            this._meterProvider = meterProvider;
+            api_1.metrics.setGlobalMeterProvider(meterProvider);
+            // TODO: This is a workaround to fix https://github.com/open-telemetry/opentelemetry-js/issues/3609
+            // If the MeterProvider is not yet registered when instrumentations are registered, all metrics are dropped.
+            // This code is obsolete once https://github.com/open-telemetry/opentelemetry-js/issues/3622 is implemented.
+            for (const instrumentation of this._instrumentations) {
+                instrumentation.setMeterProvider(api_1.metrics.getMeterProvider());
+            }
+        }
+    }
+    shutdown() {
+        const promises = [];
+        if (this._tracerProvider) {
+            promises.push(this._tracerProvider.shutdown());
+        }
+        if (this._loggerProvider) {
+            promises.push(this._loggerProvider.shutdown());
+        }
+        if (this._meterProvider) {
+            promises.push(this._meterProvider.shutdown());
+        }
+        return (Promise.all(promises)
+            // return void instead of the array from Promise.all
+            .then(() => { }));
+    }
+    configureLoggerProviderFromEnv() {
+        const logExportersList = process.env.OTEL_LOGS_EXPORTER ?? '';
+        const enabledExporters = (0, utils_1.filterBlanksAndNulls)(logExportersList.split(','));
+        if (enabledExporters.length === 0) {
+            api_1.diag.debug('OTEL_LOGS_EXPORTER is empty. Using default otlp exporter.');
+            enabledExporters.push('otlp');
+        }
+        if (enabledExporters.includes('none')) {
+            api_1.diag.info(`OTEL_LOGS_EXPORTER contains "none". Logger provider will not be initialized.`);
+            return;
+        }
+        const exporters = [];
+        enabledExporters.forEach(exporter => {
+            if (exporter === 'otlp') {
+                const protocol = (process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ??
+                    process.env.OTEL_EXPORTER_OTLP_PROTOCOL)?.trim();
+                switch (protocol) {
+                    case 'grpc':
+                        exporters.push(new exporter_logs_otlp_grpc_1.OTLPLogExporter());
+                        break;
+                    case 'http/json':
+                        exporters.push(new exporter_logs_otlp_http_1.OTLPLogExporter());
+                        break;
+                    case 'http/protobuf':
+                        exporters.push(new exporter_logs_otlp_proto_1.OTLPLogExporter());
+                        break;
+                    case undefined:
+                    case '':
+                        exporters.push(new exporter_logs_otlp_proto_1.OTLPLogExporter());
+                        break;
+                    default:
+                        api_1.diag.warn(`Unsupported OTLP logs protocol: "${protocol}". Using http/protobuf.`);
+                        exporters.push(new exporter_logs_otlp_proto_1.OTLPLogExporter());
+                }
+            }
+            else if (exporter === 'console') {
+                exporters.push(new sdk_logs_1.ConsoleLogRecordExporter());
+            }
+            else {
+                api_1.diag.warn(`Unsupported OTEL_LOGS_EXPORTER value: "${exporter}". Supported values are: otlp, console, none.`);
+            }
+        });
+        if (exporters.length > 0) {
+            this._loggerProviderConfig = {
+                logRecordProcessors: exporters.map(exporter => {
+                    if (exporter instanceof sdk_logs_1.ConsoleLogRecordExporter) {
+                        return new sdk_logs_1.SimpleLogRecordProcessor(exporter);
+                    }
+                    else {
+                        return new sdk_logs_1.BatchLogRecordProcessor(exporter);
+                    }
+                }),
+            };
+        }
+    }
+}
+exports.NodeSDK = NodeSDK;
+//# sourceMappingURL=sdk.js.map

node_modules/@opentelemetry/sdk-node/build/src/types.d.ts

@@ -0,0 +1,29 @@
+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';
+export interface NodeSDKConfiguration {
+    autoDetectResources: boolean;
+    contextManager: ContextManager;
+    textMapPropagator: TextMapPropagator;
+    /** @deprecated use logRecordProcessors instead*/
+    logRecordProcessor: LogRecordProcessor;
+    logRecordProcessors?: LogRecordProcessor[];
+    metricReader: IMetricReader;
+    views: ViewOptions[];
+    instrumentations: (Instrumentation | Instrumentation[])[];
+    resource: Resource;
+    resourceDetectors: Array<ResourceDetector>;
+    sampler: Sampler;
+    serviceName?: string;
+    /** @deprecated use spanProcessors instead*/
+    spanProcessor?: SpanProcessor;
+    spanProcessors?: SpanProcessor[];
+    traceExporter: SpanExporter;
+    spanLimits: SpanLimits;
+    idGenerator: IdGenerator;
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/@opentelemetry/sdk-node/build/src/types.js

@@ -0,0 +1,18 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

node_modules/@opentelemetry/sdk-node/build/src/types.js.map

@@ -0,0 +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;\n  /** @deprecated use logRecordProcessors instead*/\n  logRecordProcessor: LogRecordProcessor;\n  logRecordProcessors?: LogRecordProcessor[];\n  metricReader: 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"]}

node_modules/@opentelemetry/sdk-node/build/src/utils.d.ts

@@ -0,0 +1,12 @@
+import { TextMapPropagator } from '@opentelemetry/api';
+import { ResourceDetector } from '@opentelemetry/resources';
+import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+export declare function getResourceDetectorsFromEnv(): Array<ResourceDetector>;
+export declare function filterBlanksAndNulls(list: string[]): string[];
+export declare function getOtlpProtocolFromEnv(): string;
+export declare function getSpanProcessorsFromEnv(): SpanProcessor[];
+/**
+ * Get a propagator as defined by environment variables
+ */
+export declare function getPropagatorFromEnv(): TextMapPropagator | null | undefined;
+//# sourceMappingURL=utils.d.ts.map

node_modules/@opentelemetry/sdk-node/build/src/utils.js

@@ -0,0 +1,194 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropagatorFromEnv = exports.getSpanProcessorsFromEnv = exports.getOtlpProtocolFromEnv = exports.filterBlanksAndNulls = exports.getResourceDetectorsFromEnv = 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");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const exporter_trace_otlp_grpc_1 = require("@opentelemetry/exporter-trace-otlp-grpc");
+const exporter_zipkin_1 = require("@opentelemetry/exporter-zipkin");
+const resources_1 = require("@opentelemetry/resources");
+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 RESOURCE_DETECTOR_ENVIRONMENT = 'env';
+const RESOURCE_DETECTOR_HOST = 'host';
+const RESOURCE_DETECTOR_OS = 'os';
+const RESOURCE_DETECTOR_PROCESS = 'process';
+const RESOURCE_DETECTOR_SERVICE_INSTANCE_ID = 'serviceinstance';
+function getResourceDetectorsFromEnv() {
+    // When updating this list, make sure to also update the section `resourceDetectors` on README.
+    const resourceDetectors = new Map([
+        [RESOURCE_DETECTOR_ENVIRONMENT, resources_1.envDetector],
+        [RESOURCE_DETECTOR_HOST, resources_1.hostDetector],
+        [RESOURCE_DETECTOR_OS, resources_1.osDetector],
+        [RESOURCE_DETECTOR_SERVICE_INSTANCE_ID, resources_1.serviceInstanceIdDetector],
+        [RESOURCE_DETECTOR_PROCESS, resources_1.processDetector],
+    ]);
+    const resourceDetectorsFromEnv = process.env.OTEL_NODE_RESOURCE_DETECTORS?.split(',') ?? ['all'];
+    if (resourceDetectorsFromEnv.includes('all')) {
+        return [...resourceDetectors.values()].flat();
+    }
+    if (resourceDetectorsFromEnv.includes('none')) {
+        return [];
+    }
+    return resourceDetectorsFromEnv.flatMap(detector => {
+        const resourceDetector = resourceDetectors.get(detector);
+        if (!resourceDetector) {
+            api_1.diag.warn(`Invalid resource detector "${detector}" specified in the environment variable OTEL_NODE_RESOURCE_DETECTORS`);
+        }
+        return resourceDetector || [];
+    });
+}
+exports.getResourceDetectorsFromEnv = getResourceDetectorsFromEnv;
+function filterBlanksAndNulls(list) {
+    return list.map(item => item.trim()).filter(s => s !== 'null' && s !== '');
+}
+exports.filterBlanksAndNulls = filterBlanksAndNulls;
+function getOtlpProtocolFromEnv() {
+    return ((0, core_1.getStringFromEnv)('OTEL_EXPORTER_OTLP_TRACES_PROTOCOL') ??
+        (0, core_1.getStringFromEnv)('OTEL_EXPORTER_OTLP_PROTOCOL') ??
+        'http/protobuf');
+}
+exports.getOtlpProtocolFromEnv = getOtlpProtocolFromEnv;
+function getOtlpExporterFromEnv() {
+    const protocol = getOtlpProtocolFromEnv();
+    switch (protocol) {
+        case 'grpc':
+            return new exporter_trace_otlp_grpc_1.OTLPTraceExporter();
+        case 'http/json':
+            return new exporter_trace_otlp_http_1.OTLPTraceExporter();
+        case 'http/protobuf':
+            return new exporter_trace_otlp_proto_1.OTLPTraceExporter();
+        default:
+            api_1.diag.warn(`Unsupported OTLP traces protocol: ${protocol}. Using http/protobuf.`);
+            return new exporter_trace_otlp_proto_1.OTLPTraceExporter();
+    }
+}
+function getJaegerExporter() {
+    // The JaegerExporter does not support being required in bundled
+    // environments. By delaying the require statement to here, we only crash when
+    // the exporter is actually used in such an environment.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');
+        return new JaegerExporter();
+    }
+    catch (e) {
+        throw new Error(`Could not instantiate JaegerExporter. This could be due to the JaegerExporter's lack of support for bundling. If possible, use @opentelemetry/exporter-trace-otlp-proto instead. Original Error: ${e}`);
+    }
+}
+function getSpanProcessorsFromEnv() {
+    const exportersMap = new Map([
+        ['otlp', () => getOtlpExporterFromEnv()],
+        ['zipkin', () => new exporter_zipkin_1.ZipkinExporter()],
+        ['console', () => new sdk_trace_base_1.ConsoleSpanExporter()],
+        ['jaeger', () => getJaegerExporter()],
+    ]);
+    const exporters = [];
+    const processors = [];
+    let traceExportersList = filterBlanksAndNulls(Array.from(new Set((0, core_1.getStringListFromEnv)('OTEL_TRACES_EXPORTER'))));
+    if (traceExportersList[0] === 'none') {
+        api_1.diag.warn('OTEL_TRACES_EXPORTER contains "none". SDK will not be initialized.');
+        return [];
+    }
+    if (traceExportersList.length === 0) {
+        api_1.diag.debug('OTEL_TRACES_EXPORTER is empty. Using default otlp exporter.');
+        traceExportersList = ['otlp'];
+    }
+    else if (traceExportersList.length > 1 &&
+        traceExportersList.includes('none')) {
+        api_1.diag.warn('OTEL_TRACES_EXPORTER contains "none" along with other exporters. Using default otlp exporter.');
+        traceExportersList = ['otlp'];
+    }
+    for (const name of traceExportersList) {
+        const exporter = exportersMap.get(name)?.();
+        if (exporter) {
+            exporters.push(exporter);
+        }
+        else {
+            api_1.diag.warn(`Unrecognized OTEL_TRACES_EXPORTER value: ${name}.`);
+        }
+    }
+    for (const exp of exporters) {
+        if (exp instanceof sdk_trace_base_1.ConsoleSpanExporter) {
+            processors.push(new sdk_trace_base_1.SimpleSpanProcessor(exp));
+        }
+        else {
+            processors.push(new sdk_trace_base_1.BatchSpanProcessor(exp));
+        }
+    }
+    if (exporters.length === 0) {
+        api_1.diag.warn('Unable to set up trace exporter(s) due to invalid exporter and/or protocol values.');
+    }
+    return processors;
+}
+exports.getSpanProcessorsFromEnv = getSpanProcessorsFromEnv;
+/**
+ * Get a propagator as defined by environment variables
+ */
+function getPropagatorFromEnv() {
+    // Empty and undefined MUST be treated equal.
+    const propagatorsEnvVarValue = (0, core_1.getStringListFromEnv)('OTEL_PROPAGATORS');
+    if (propagatorsEnvVarValue == null) {
+        // return undefined to fall back to default
+        return undefined;
+    }
+    // Implementation note: this only contains specification required propagators that are actually hosted in this repo.
+    // Any other propagators (like aws, aws-lambda, should go into `@opentelemetry/auto-configuration-propagators` instead).
+    const propagatorsFactory = new Map([
+        ['tracecontext', () => new core_1.W3CTraceContextPropagator()],
+        ['baggage', () => new core_1.W3CTraceContextPropagator()],
+        ['b3', () => new propagator_b3_1.B3Propagator()],
+        [
+            'b3multi',
+            () => new propagator_b3_1.B3Propagator({ injectEncoding: propagator_b3_1.B3InjectEncoding.MULTI_HEADER }),
+        ],
+        ['jaeger', () => new propagator_jaeger_1.JaegerPropagator()],
+    ]);
+    // Values MUST be deduplicated in order to register a Propagator only once.
+    const uniquePropagatorNames = Array.from(new Set(propagatorsEnvVarValue));
+    const propagators = uniquePropagatorNames.map(name => {
+        const propagator = propagatorsFactory.get(name)?.();
+        if (!propagator) {
+            api_1.diag.warn(`Propagator "${name}" requested through environment variable is unavailable.`);
+            return undefined;
+        }
+        return propagator;
+    });
+    const validPropagators = propagators.reduce((list, item) => {
+        if (item) {
+            list.push(item);
+        }
+        return list;
+    }, []);
+    if (validPropagators.length === 0) {
+        // null to signal that the default should **not** be used in its place.
+        return null;
+    }
+    else if (uniquePropagatorNames.length === 1) {
+        return validPropagators[0];
+    }
+    else {
+        return new core_1.CompositePropagator({
+            propagators: validPropagators,
+        });
+    }
+}
+exports.getPropagatorFromEnv = getPropagatorFromEnv;
+//# sourceMappingURL=utils.js.map

node_modules/@opentelemetry/sdk-node/build/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.200.0";
+//# sourceMappingURL=version.d.ts.map

node_modules/@opentelemetry/sdk-node/build/src/version.js

@@ -0,0 +1,21 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// this is autogenerated file, see scripts/version-update.js
+exports.VERSION = '0.200.0';
+//# sourceMappingURL=version.js.map

node_modules/@opentelemetry/sdk-node/build/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,4DAA4D;AAC/C,QAAA,OAAO,GAAG,SAAS,CAAC","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\n// this is autogenerated file, see scripts/version-update.js\nexport const VERSION = '0.200.0';\n"]}