feat(otel-node)!: update to SDK 2.0

packages/opentelemetry-node/lib/detectors.js

@@ -4,11 +4,7 @@
  */
 
 /**
- * NOTE: when `Detector` is finally removed import only `DetectorSync` and
- * get rid of the aliasing
- * @typedef {import('@opentelemetry/resources').Detector} DetectorOrig
- * @typedef {import('@opentelemetry/resources').DetectorSync} DetectorSyncOrig
- * @typedef {DetectorOrig | DetectorSyncOrig} DetectorSync
+ * @typedef {import('@opentelemetry/resources').ResourceDetector} ResourceDetector
  */
 
 const {
@@ -31,41 +27,42 @@ const {
 } = require('@opentelemetry/resource-detector-container');
 const {gcpDetector} = require('@opentelemetry/resource-detector-gcp');
 const {
-    envDetectorSync,
-    hostDetectorSync,
-    osDetectorSync,
-    processDetectorSync,
-    serviceInstanceIdDetectorSync,
-    Resource,
+    envDetector,
+    hostDetector,
+    osDetector,
+    processDetector,
+    serviceInstanceIdDetector,
 } = require('@opentelemetry/resources');
 
-const {getEnvVar} = require('./environment');
 const {log} = require('./logging');
+const {getEnvStringList} = require('./environment');
 
 // @ts-ignore - compiler options do not allow lookp outside `lib` folder
 const ELASTIC_SDK_VERSION = require('../package.json').version;
 
 // Elastic's own detector to add distro related metadata
-/** @type {DetectorSync} */
-const distroDetectorSync = {
+/** @type {ResourceDetector} */
+const distroDetector = {
     detect() {
         // TODO: change to semconv resource attribs when
         // `@opentelemetry/semantic-conventions` gets updated with the attribs used
         // https://github.com/open-telemetry/opentelemetry-js/issues/4235
-        return new Resource({
-            'telemetry.distro.name': 'elastic',
-            'telemetry.distro.version': ELASTIC_SDK_VERSION,
-        });
+        return {
+            attributes: {
+                'telemetry.distro.name': 'elastic',
+                'telemetry.distro.version': ELASTIC_SDK_VERSION,
+            },
+        };
     },
 };
 
-/** @type {Record<string, DetectorSync | Array<DetectorSync>>} */
+/** @type {Record<string, ResourceDetector | Array<ResourceDetector>>} */
 const defaultDetectors = {
-    env: envDetectorSync,
-    process: processDetectorSync,
-    serviceinstance: serviceInstanceIdDetectorSync,
-    os: osDetectorSync,
-    host: hostDetectorSync,
+    env: envDetector,
+    process: processDetector,
+    serviceinstance: serviceInstanceIdDetector,
+    os: osDetector,
+    host: hostDetector,
     container: containerDetector,
     alibaba: alibabaCloudEcsDetector,
     aws: [
@@ -80,25 +77,28 @@ const defaultDetectors = {
 };
 
 /**
- * @param {Array<DetectorSync>} [detectors]
- * @returns {Array<DetectorSync>}
+ * @param {Array<ResourceDetector>} [detectors]
+ * @returns {Array<ResourceDetector>}
  */
 function resolveDetectors(detectors) {
     if (detectors) {
-        detectors.push(distroDetectorSync);
+        detectors.push(distroDetector);
         return detectors;
     }
 
-    let detectorKeys = getEnvVar('OTEL_NODE_RESOURCE_DETECTORS');
+    let detectorKeys = getEnvStringList('OTEL_NODE_RESOURCE_DETECTORS', [
+        'all',
+    ]);
     if (detectorKeys.some((k) => k === 'all')) {
         detectorKeys = Object.keys(defaultDetectors);
     } else if (detectorKeys.some((k) => k === 'none')) {
         return [];
     }
 
-    /** @type {Array<DetectorSync | DetectorSync[]>} */
-    const resolvedDetectors = [distroDetectorSync];
+    /** @type {Array<ResourceDetector | ResourceDetector[]>} */
+    const resolvedDetectors = [distroDetector];
     for (const key of detectorKeys) {
+        log.warn(`resolving detector ${key}`);
         if (defaultDetectors[key]) {
             resolvedDetectors.push(defaultDetectors[key]);
         } else {

packages/opentelemetry-node/lib/elastic-node-sdk.js

@@ -17,7 +17,9 @@ const {resolveDetectors} = require('./detectors');
 const {
     setupEnvironment,
     restoreEnvironment,
-    getEnvVar,
+    getEnvString,
+    getEnvBoolean,
+    getEnvNumber,
 } = require('./environment');
 const {getInstrumentations} = require('./instrumentations');
 const {enableHostMetrics, HOST_METRICS_VIEWS} = require('./metrics/host');
@@ -53,7 +55,7 @@ class ElasticNodeSDK extends NodeSDK {
         // Get logs exporter protocol based on environment.
         const logsExportProtocol =
             process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL ||
-            getEnvVar('OTEL_EXPORTER_OTLP_PROTOCOL');
+            getEnvString('OTEL_EXPORTER_OTLP_PROTOCOL');
         let logExporterType = exporterPkgNameFromEnvVar[logsExportProtocol];
         if (!logExporterType) {
             log.warn(
@@ -77,12 +79,15 @@ class ElasticNodeSDK extends NodeSDK {
         // TODO what `temporalityPreference`?
 
         // Disable metrics by config
-        const metricsDisabled = getEnvVar('ELASTIC_OTEL_METRICS_DISABLED');
+        const metricsDisabled = getEnvBoolean(
+            'ELASTIC_OTEL_METRICS_DISABLED',
+            false
+        );
         if (!metricsDisabled) {
             // Get metrics exporter protocol based on environment.
             const metricsExportProtocol =
                 process.env.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL ||
-                getEnvVar('OTEL_EXPORTER_OTLP_PROTOCOL');
+                getEnvString('OTEL_EXPORTER_OTLP_PROTOCOL');
             let metricExporterType =
                 exporterPkgNameFromEnvVar[metricsExportProtocol];
             if (!metricExporterType) {
@@ -98,8 +103,16 @@ class ElasticNodeSDK extends NodeSDK {
                 `@opentelemetry/exporter-metrics-otlp-${metricExporterType}`
             );
 
-            const metricsInterval = getEnvVar('OTEL_METRIC_EXPORT_INTERVAL');
-            const metricsTimeout = getEnvVar('OTEL_METRIC_EXPORT_TIMEOUT');
+            // Note: Default values has been taken from the specs
+            // https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#periodic-exporting-metricreader
+            const metricsInterval = getEnvNumber(
+                'OTEL_METRIC_EXPORT_INTERVAL',
+                60000
+            );
+            const metricsTimeout = getEnvNumber(
+                'OTEL_METRIC_EXPORT_TIMEOUT',
+                30000
+            );
             defaultConfig.metricReader =
                 new metrics.PeriodicExportingMetricReader({
                     exporter: new OTLPMetricExporter(),

packages/opentelemetry-node/lib/environment.js

@@ -3,55 +3,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// NOTE: this API may be removed in future
-// ref: https://github.com/open-telemetry/opentelemetry-js/issues/5172
-const {getEnv} = require('@opentelemetry/core');
+const {
+    getBooleanFromEnv,
+    getNumberFromEnv,
+    getStringListFromEnv,
+    getStringFromEnv,
+} = require('@opentelemetry/core');
 
 /** @type {NodeJS.ProcessEnv} */
 const envToRestore = {};
 
-/**
- * Returns an array of strings from the given input. If undefined returns the fallback
- * value.
- * @param {string | undefined} str
- * @param {string[]} [fallback=[]]
- * @returns {string[]}
- */
-function parseStringList(str, fallback = []) {
-    if (!str) {
-        return fallback;
-    }
-    return str.split(',').map((s) => s.trim());
-}
-
-/**
- * Returns a boolean from the given input
- * @param {string | undefined} str
- * @param {boolean} fallback
- * @returns {boolean}
- */
-function parseBoolean(str, fallback) {
-    if (!str) {
-        return fallback;
-    }
-    return str.toLowerCase() === 'true';
-}
-
-/**
- * Returns a boolean from te given input
- * @param {string | undefined} str
- * @param {number} fallback
- * @returns {number}
- */
-function parseNumber(str, fallback) {
-    if (!str) {
-        return fallback;
-    }
-
-    const num = Number(str);
-    return isNaN(num) ? fallback : num;
-}
-
 /**
  * This funtion makes necessari changes to the environment so:
  * - Avoid OTEL's NodeSDK known warnings (eg. OTEL_TRACES_EXPORTER not set)
@@ -86,75 +47,42 @@ function setupEnvironment() {
 function restoreEnvironment() {
     Object.keys(envToRestore).forEach((k) => {
         process.env[k] = envToRestore[k];
+        delete envToRestore[k];
     });
 }
 
-/**
- * @typedef {Object} EdotEnv
- * @property {string[]} OTEL_NODE_RESOURCE_DETECTORS
- * @property {number} OTEL_METRIC_EXPORT_INTERVAL
- * @property {number} OTEL_METRIC_EXPORT_TIMEOUT
- * @property {boolean} ELASTIC_OTEL_METRICS_DISABLED
- */
-/**
- * @typedef {keyof EdotEnv} EdotEnvKey
- */
-/** @type {EdotEnv} */
-const edotEnv = {
-    // Missing OTEL_ vars from global spec and nodejs specific spec
-    OTEL_NODE_RESOURCE_DETECTORS: parseStringList(
-        process.env.OTEL_NODE_RESOURCE_DETECTORS,
-        ['all']
-    ),
-    // Note: Default values has been taken from the specs
-    // https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#periodic-exporting-metricreader
-    OTEL_METRIC_EXPORT_INTERVAL: parseNumber(
-        process.env.OTEL_METRIC_EXPORT_INTERVAL,
-        60000
-    ),
-    OTEL_METRIC_EXPORT_TIMEOUT: parseNumber(
-        process.env.OTEL_METRIC_EXPORT_TIMEOUT,
-        30000
-    ),
-    // ELASTIC_OTEL_ vars
-    ELASTIC_OTEL_METRICS_DISABLED: parseBoolean(
-        process.env.ELASTIC_OTEL_METRICS_DISABLED,
-        false
-    ),
-};
-
-/**
- * @typedef {import('@opentelemetry/core').ENVIRONMENT} OtelEnv
- */
-/**
- * @typedef {keyof OtelEnv} OtelEnvKey
- */
-const otelEnv = getEnv();
-
 /**
  * @template T
- * @typedef {T extends OtelEnvKey ? OtelEnv[T] : T extends EdotEnvKey ? EdotEnv[T] : never} EnvValue<T>
- */
-/**
- * @template {OtelEnvKey | EdotEnvKey} T
- * Returns the value of the env var already parsed to the proper type. If
- * the variable is not defined it will return the default value based on
- * the environmment variables spec https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/
- * @param {T} name
- * @returns {EnvValue<T>}
+ * @param {(name: string) => T} getterFn
+ * @returns {(name: string, defaultValue?: T) => T}
  */
-function getEnvVar(name) {
-    if (name in otelEnv) {
-        // @ts-ignore -- T is {keyof OtelEnv} but not sure how to make TS infer that
-        return otelEnv[name];
-    }
+function makeEnvVarGetter(getterFn) {
+    return function (name, defaultValue = undefined) {
+        const isStashed = name in envToRestore;
+        let result;
 
-    // @ts-ignore -- T is {keyof EdotEnv} but not sure how to make TS infer that
-    return edotEnv[name];
+        if (isStashed) {
+            process.env[name] = envToRestore[name];
+        }
+        result = getterFn(name);
+        if (isStashed) {
+            delete process.env[name];
+        }
+
+        return typeof result === 'undefined' ? defaultValue : result;
+    };
 }
 
+const getEnvBoolean = makeEnvVarGetter(getBooleanFromEnv);
+const getEnvNumber = makeEnvVarGetter(getNumberFromEnv);
+const getEnvString = makeEnvVarGetter(getStringFromEnv);
+const getEnvStringList = makeEnvVarGetter(getStringListFromEnv);
+
 module.exports = {
     setupEnvironment,
     restoreEnvironment,
-    getEnvVar,
+    getEnvBoolean,
+    getEnvNumber,
+    getEnvString,
+    getEnvStringList,
 };

packages/opentelemetry-node/lib/instrumentations.js

@@ -95,8 +95,8 @@ const {TediousInstrumentation} = require('@opentelemetry/instrumentation-tedious
 const {UndiciInstrumentation} = require('@opentelemetry/instrumentation-undici');
 const {WinstonInstrumentation} = require('@opentelemetry/instrumentation-winston');
 
+const {getEnvStringList, getEnvBoolean} = require('./environment');
 const {log} = require('./logging');
-const {getEnvVar} = require('./environment');
 
 // Instrumentations attach their Hook (for require-in-the-middle or import-in-the-middle)
 // when the `enable` method is called and this happens inside their constructor
@@ -179,9 +179,9 @@ for (const name of Object.keys(instrumentationsMap)) {
  * @returns {Array<string> | undefined}
  */
 function getInstrumentationsFromEnv(envvar) {
-    if (process.env[envvar]) {
+    const names = getEnvStringList(envvar);
+    if (names) {
         const instrumentations = [];
-        const names = process.env[envvar].split(',').map((s) => s.trim());
 
         for (const name of names) {
             if (otelInstrShortNames.has(name)) {
@@ -267,7 +267,10 @@ function getInstrumentations(opts = {}) {
         }
 
         // Skip if metrics are disabled by env var
-        const isMetricsDisabled = getEnvVar('ELASTIC_OTEL_METRICS_DISABLED');
+        const isMetricsDisabled = getEnvBoolean(
+            'ELASTIC_OTEL_METRICS_DISABLED',
+            false
+        );
         if (
             isMetricsDisabled &&
             name === '@opentelemetry/instrumentation-runtime-node'

packages/opentelemetry-node/lib/metrics/host.js

@@ -4,8 +4,7 @@
  */
 
 const {metrics} = require('@opentelemetry/api');
-const {metrics: metricsSdk} = require('@opentelemetry/sdk-node');
-const {Aggregation, View} = metricsSdk;
+const {AggregationType} = require('@opentelemetry/sdk-metrics');
 const {HostMetrics} = require('@opentelemetry/host-metrics');
 
 /** @type {HostMetrics} */
@@ -22,12 +21,12 @@ function enableHostMetrics() {
 // - sends a lot of data. Ref: https://github.com/elastic/elastic-otel-node/issues/51
 // - not displayed by Kibana in metrics dashboard. Ref: https://github.com/elastic/kibana/pull/199353
 // - recommendation is to use OTEL collector to get and export them
-/** @type {metricsSdk.View[]} */
+/** @type {import('@opentelemetry/sdk-metrics').ViewOptions[]} */
 const HOST_METRICS_VIEWS = [
-    new View({
+    {
         instrumentName: 'system.*',
-        aggregation: Aggregation.Drop(),
-    }),
+        aggregation: {type: AggregationType.DROP},
+    },
 ];
 
 module.exports = {