@sophonz/node-sdk 0.0.1

package/build/src/otel.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTraceAttributes = exports.shutdown = exports.init = exports.initSDK = void 0;
+const tslib_1 = require("tslib");
+const instrumentation_node_exception_1 = require("@sophonz/instrumentation-node-exception");
+const instrumentation_node_1 = require("@sophonz/instrumentation-node");
+const api_1 = require("@opentelemetry/api");
+const auto_instrumentations_node_1 = require("@opentelemetry/auto-instrumentations-node");
+const exporter_trace_otlp_proto_1 = require("@opentelemetry/exporter-trace-otlp-proto");
+const instrumentation_runtime_node_1 = require("@opentelemetry/instrumentation-runtime-node");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const cli_spinners_1 = tslib_1.__importDefault(require("cli-spinners"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const semver = tslib_1.__importStar(require("semver"));
+const shimmer_1 = require("shimmer");
+const package_json_1 = require("../package.json");
+const constants_1 = require("./constants");
+const console_1 = tslib_1.__importDefault(require("./instrumentations/console"));
+const http_1 = require("./instrumentations/http");
+const metrics_1 = require("./metrics");
+const MutableAsyncLocalStorageContextManager_1 = require("./MutableAsyncLocalStorageContextManager");
+const otel_logger_1 = require("./otel-logger");
+const spanProcessor_1 = tslib_1.__importDefault(require("./spanProcessor"));
+const UI_LOG_PREFIX = '[⚡Sophonz]';
+const env = process.env;
+const IS_LOCAL = env.NODE_ENV === 'development' || !env.NODE_ENV;
+const setOtelEnvs = ({ apiKey, disableLogs, disableMetrics, disableTracing, service, }) => {
+    var _a;
+    env.OTEL_NODE_RESOURCE_DETECTORS = (_a = env.OTEL_NODE_RESOURCE_DETECTORS) !== null && _a !== void 0 ? _a : 'all';
+    env.OTEL_TRACES_SAMPLER = constants_1.DEFAULT_OTEL_TRACES_SAMPLER;
+    env.OTEL_TRACES_SAMPLER_ARG = constants_1.DEFAULT_OTEL_TRACES_SAMPLER_ARG;
+    env.OTEL_SERVICE_NAME = service;
+    if (disableLogs) {
+        env.OTEL_LOGS_EXPORTER = 'none';
+    }
+    if (disableTracing) {
+        env.OTEL_TRACES_EXPORTER = 'none';
+    }
+    if (disableMetrics) {
+        env.OTEL_METRICS_EXPORTER = 'none';
+    }
+    if (apiKey) {
+        if (env.OTEL_EXPORTER_OTLP_HEADERS) {
+            env.OTEL_EXPORTER_OTLP_HEADERS = `${env.OTEL_EXPORTER_OTLP_HEADERS},Authorization=${apiKey}`;
+        }
+        else {
+            env.OTEL_EXPORTER_OTLP_HEADERS = `Authorization=${apiKey}`;
+        }
+    }
+};
+let sdk;
+let contextManager;
+const getModuleId = (moduleName) => {
+    try {
+        const moduleId = require.resolve(moduleName);
+        return moduleId;
+    }
+    catch (e) {
+        api_1.diag.error('Error resolving module id', e);
+        return null;
+    }
+};
+const isSupported = (supportedVersions, version, includePrerelease) => {
+    if (typeof version === 'undefined') {
+        return supportedVersions.includes('*');
+    }
+    return supportedVersions.some((supportedVersion) => {
+        return semver.satisfies(version, supportedVersion, { includePrerelease });
+    });
+};
+const hrtimeToMs = (hrtime) => {
+    return hrtime[0] * 1e3 + hrtime[1] / 1e6;
+};
+const healthCheckUrl = async (ui, url, requestConfigs) => {
+    ui.text = `Checking health of ${url}...`;
+    try {
+        const res = await (0, node_fetch_1.default)(url, requestConfigs);
+        if (res.ok) {
+            ui.succeed(`Health check passed for ${url}`);
+        }
+        else {
+            ui.fail(`Health check failed for ${url}`);
+        }
+    }
+    catch (e) {
+        api_1.diag.error('Error checking health of url', e);
+        ui.fail(`Health check failed for ${url}`);
+    }
+};
+const initSDK = (config) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _o, _p, _q, _r, _s, _t;
+    const defaultDisableStartupLogs = (_a = config.disableStartupLogs) !== null && _a !== void 0 ? _a : !constants_1.DEFAULT_SOPHONZ_STARTUP_LOGS;
+    const ui = (0, ora_1.default)({
+        isSilent: defaultDisableStartupLogs,
+        prefixText: UI_LOG_PREFIX,
+        spinner: cli_spinners_1.default.dots,
+        text: 'Initializing OpenTelemetry SDK...',
+    }).start();
+    const defaultApiKey = (_b = config.apiKey) !== null && _b !== void 0 ? _b : (0, constants_1.DEFAULT_SOPHONZ_API_KEY)();
+    const defaultDetectResources = (_c = config.detectResources) !== null && _c !== void 0 ? _c : true;
+    const defaultDisableLogs = (_d = config.disableLogs) !== null && _d !== void 0 ? _d : constants_1.DEFAULT_OTEL_LOGS_EXPORTER === 'none';
+    const defaultDisableMetrics = (_e = config.disableMetrics) !== null && _e !== void 0 ? _e : constants_1.DEFAULT_OTEL_METRICS_EXPORTER === 'none';
+    const defaultDisableTracing = (_f = config.disableTracing) !== null && _f !== void 0 ? _f : constants_1.DEFAULT_OTEL_TRACES_EXPORTER === 'none';
+    const defaultEnableInternalProfiling = (_g = config.enableInternalProfiling) !== null && _g !== void 0 ? _g : false;
+    const defaultServiceName = (_h = config.service) !== null && _h !== void 0 ? _h : (0, constants_1.DEFAULT_SERVICE_NAME)();
+    ui.succeed(`Service name is configured to be "${defaultServiceName}"`);
+    if (!env.OTEL_EXPORTER_OTLP_HEADERS && !defaultApiKey) {
+        ui.fail('apiKey or SOPHONZ_API_KEY or OTEL_EXPORTER_OTLP_HEADERS is not set');
+        ui.stopAndPersist({
+            text: 'OpenTelemetry SDK initialization skipped',
+            symbol: '🚫',
+        });
+        return;
+    }
+    ui.text = 'Setting otel envs...';
+    setOtelEnvs({
+        apiKey: defaultApiKey,
+        disableLogs: defaultDisableLogs,
+        disableMetrics: defaultDisableMetrics,
+        disableTracing: defaultDisableTracing,
+        service: defaultServiceName,
+    });
+    ui.succeed('Set default otel envs');
+    const stopOnTerminationSignals = (_j = config.stopOnTerminationSignals) !== null && _j !== void 0 ? _j : constants_1.DEFAULT_SOPHONZ_NODE_STOP_ON_TERMINATION_SIGNALS;
+    let defaultConsoleCapture = (_k = config.consoleCapture) !== null && _k !== void 0 ? _k : constants_1.DEFAULT_SOPHONZ_NODE_CONSOLE_CAPTURE;
+    if (constants_1.DEFAULT_OTEL_LOG_LEVEL === 'debug' || constants_1.DEFAULT_OTEL_LOG_LEVEL === String(api_1.DiagLogLevel.DEBUG)) {
+        defaultConsoleCapture = false;
+        ui.warn(`OTEL_LOG_LEVEL is set to 'debug', disabling console instrumentation`);
+    }
+    ui.text = 'Initializing OpenTelemetry Logger...';
+    const _logger = new otel_logger_1.Logger({
+        detectResource: defaultDetectResources,
+        service: defaultServiceName,
+    });
+    ui.succeed('Initialized OpenTelemetry Logger');
+    Promise.all([
+        healthCheckUrl(ui, constants_1.DEFAULT_OTEL_TRACES_EXPORTER_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({}),
+        }),
+        healthCheckUrl(ui, _logger.getExporterUrl(), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({}),
+        }),
+        healthCheckUrl(ui, constants_1.DEFAULT_OTEL_METRICS_EXPORTER_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({}),
+        }),
+    ]);
+    const defaultBetaMode = (_l = config.betaMode) !== null && _l !== void 0 ? _l : (0, constants_1.DEFAULT_SOPHONZ_NODE_BETA_MODE)();
+    const defaultAdvancedNetworkCapture = (_o = config.advancedNetworkCapture) !== null && _o !== void 0 ? _o : constants_1.DEFAULT_SOPHONZ_NODE_ADVANCED_NETWORK_CAPTURE;
+    const defaultExceptionCapture = (_p = config.experimentalExceptionCapture) !== null && _p !== void 0 ? _p : constants_1.DEFAULT_SOPHONZ_NODE_EXPERIMENTAL_EXCEPTION_CAPTURE;
+    const defaultSentryIntegrationEnabled = (_q = config.sentryIntegrationEnabled) !== null && _q !== void 0 ? _q : constants_1.DEFAULT_SOPHONZ_NODE_SENTRY_INTEGRATION_ENABLED;
+    contextManager = semver.gte(process.version, '14.8.0')
+        ? new MutableAsyncLocalStorageContextManager_1.MutableAsyncLocalStorageContextManager()
+        : undefined;
+    ui.text = 'Initializing instrumentations packages...';
+    const allInstrumentations = [
+        ...(0, auto_instrumentations_node_1.getNodeAutoInstrumentations)({
+            '@opentelemetry/instrumentation-http': defaultAdvancedNetworkCapture
+                ? (0, http_1.getSophonzHTTPInstrumentationConfig)({
+                    httpCaptureHeadersClientRequest: env.OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_CLIENT_REQUEST,
+                    httpCaptureHeadersClientResponse: env.OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_CLIENT_RESPONSE,
+                    httpCaptureHeadersServerRequest: env.OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_REQUEST,
+                    httpCaptureHeadersServerResponse: env.OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_SERVER_RESPONSE,
+                })
+                : { enabled: true },
+            '@opentelemetry/instrumentation-fs': {
+                enabled: false,
+            },
+            ...config.instrumentations,
+        }),
+        new instrumentation_runtime_node_1.RuntimeNodeInstrumentation(),
+        ...(defaultConsoleCapture
+            ? [
+                new console_1.default({
+                    betaMode: defaultBetaMode,
+                    loggerOptions: {
+                        baseUrl: _logger.getExporterUrl(),
+                        service: defaultServiceName,
+                    },
+                    contextManager,
+                }),
+            ]
+            : []),
+        ...(defaultSentryIntegrationEnabled
+            ? [new instrumentation_node_1.SentryNodeInstrumentation()]
+            : []),
+        ...(defaultExceptionCapture
+            ? [
+                new instrumentation_node_exception_1.ExceptionInstrumentation({
+                    _internalForceFlush: exports.shutdown,
+                }),
+            ]
+            : []),
+        ...((_r = config.additionalInstrumentations) !== null && _r !== void 0 ? _r : []),
+    ];
+    sdk = new sdk_node_1.NodeSDK({
+        resource: (0, resources_1.resourceFromAttributes)({
+            'telemetry.distro.name': 'sophonz',
+            'telemetry.distro.version': package_json_1.version,
+        }),
+        logRecordProcessor: defaultDisableLogs ? undefined : _logger.getProcessor(),
+        metricReader: (_s = config.metricReader) !== null && _s !== void 0 ? _s : (defaultDisableMetrics ? undefined : (0, metrics_1.getSophonzMetricReader)()),
+        spanProcessors: [
+            ...(defaultDisableTracing
+                ? []
+                : [
+                    new spanProcessor_1.default({
+                        exporter: new exporter_trace_otlp_proto_1.OTLPTraceExporter({
+                            timeoutMillis: constants_1.DEFAULT_OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
+                            url: constants_1.DEFAULT_OTEL_TRACES_EXPORTER_URL,
+                        }),
+                        enableSophonzGlobalContext: defaultBetaMode,
+                        contextManager,
+                    }),
+                ]),
+        ],
+        instrumentations: config.programmaticImports ? [] : allInstrumentations,
+        contextManager: contextManager,
+    });
+    ui.succeed('Initialized instrumentations packages');
+    if (defaultEnableInternalProfiling) {
+        ui.text = 'Enabling internal profiling...';
+        for (const instrumentation of allInstrumentations) {
+            const _originalEnable = instrumentation.enable;
+            instrumentation.enable = function (...args) {
+                const start = process.hrtime();
+                const result = _originalEnable.apply(this, args);
+                const end = process.hrtime(start);
+                ui.succeed(`Enabled instrumentation ${instrumentation.constructor.name} in ${hrtimeToMs(end)} ms`);
+                return result;
+            };
+            const modules = instrumentation
+                ._modules;
+            for (const module of modules) {
+                if (typeof module.patch === 'function') {
+                    (0, shimmer_1.wrap)(module, 'patch', (original) => {
+                        return (...args) => {
+                            const start = process.hrtime();
+                            const result = original.apply(this, args);
+                            const end = process.hrtime(start);
+                            ui.succeed(`Instrumented ${module.name}${module.moduleVersion ? ` [v${module.moduleVersion}] ` : ' '}in ${hrtimeToMs(end)} ms`);
+                            return result;
+                        };
+                    });
+                }
+                for (const file of module.files) {
+                    if (typeof file.patch === 'function') {
+                        (0, shimmer_1.wrap)(file, 'patch', (original) => {
+                            return (...args) => {
+                                const start = process.hrtime();
+                                const result = original.apply(this, args);
+                                const end = process.hrtime(start);
+                                ui.succeed(`Instrumented ${module.name}${module.moduleVersion ? ` [v${module.moduleVersion}] ` : ' '}file ${file.name} in ${hrtimeToMs(end)} ms`);
+                                return result;
+                            };
+                        });
+                    }
+                }
+            }
+        }
+    }
+    ui.text = 'Starting OpenTelemetry Node SDK...';
+    sdk.start();
+    ui.succeed('Started OpenTelemetry Node SDK');
+    if (config.programmaticImports) {
+        ui.text = 'Repatching instrumentation packages...';
+        for (const instrumentation of allInstrumentations) {
+            const modules = instrumentation
+                ._modules;
+            if (Array.isArray(modules)) {
+                instrumentation.disable();
+                for (const module of modules) {
+                    if (getModuleId(module.name)) {
+                        try {
+                            const _m = require(module.name);
+                            module.moduleExports = _m;
+                        }
+                        catch (e) {
+                            api_1.diag.error('Error re-requiring moduleExports for nodejs module', {
+                                module: module.name,
+                                version: module.moduleVersion,
+                                error: e,
+                            });
+                        }
+                        try {
+                            const _pkg = require(path_1.default.join(module.name, 'package.json'));
+                            module.moduleVersion = _pkg.version;
+                        }
+                        catch (e) {
+                            api_1.diag.error('Error re-requiring package.json for nodejs module', {
+                                module: module.name,
+                                version: module.moduleVersion,
+                                error: e,
+                            });
+                        }
+                        if (isSupported(module.supportedVersions, module.moduleVersion, module.includePrerelease) &&
+                            typeof module.patch === 'function' &&
+                            module.moduleExports) {
+                            api_1.diag.debug('Applying instrumentation patch for nodejs module on instrumentation enabled', {
+                                module: module.name,
+                                version: module.moduleVersion,
+                            });
+                            try {
+                                module.patch(module.moduleExports, module.moduleVersion);
+                            }
+                            catch (e) {
+                                api_1.diag.error('Error applying instrumentation patch for nodejs module', e);
+                            }
+                        }
+                        const files = (_t = module.files) !== null && _t !== void 0 ? _t : [];
+                        const supportedFileInstrumentations = files.filter((f) => isSupported(f.supportedVersions, module.moduleVersion, module.includePrerelease));
+                        for (const sfi of supportedFileInstrumentations) {
+                            try {
+                                const _m = require(sfi.name);
+                                sfi.moduleExports = _m;
+                            }
+                            catch (e) {
+                                api_1.diag.error('Error re-requiring moduleExports for nodejs module file', e);
+                                continue;
+                            }
+                            api_1.diag.debug('Applying instrumentation patch for nodejs module file on require hook', {
+                                module: module.name,
+                                version: module.moduleVersion,
+                                fileName: sfi.name,
+                            });
+                            try {
+                                sfi.patch(sfi.moduleExports, module.moduleVersion);
+                            }
+                            catch (e) {
+                                api_1.diag.error('Error applying instrumentation patch for nodejs module file', e);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        ui.succeed('Repatched instrumentation packages');
+    }
+    function handleTerminationSignal(signal) {
+        api_1.diag.debug(`${signal} received, shutting down...`);
+        _shutdown().finally(() => process.exit());
+    }
+    if (stopOnTerminationSignals) {
+        process.on('SIGTERM', () => {
+            handleTerminationSignal('SIGTERM');
+        });
+        process.on('SIGINT', () => {
+            handleTerminationSignal('SIGINT');
+        });
+    }
+    if (defaultAdvancedNetworkCapture) {
+        ui.succeed(`Enabled Advanced Network Capture`);
+    }
+    if (defaultBetaMode) {
+        ui.succeed(`Enabled Beta Mode`);
+    }
+    if (defaultConsoleCapture) {
+        ui.succeed(`Enabled Console Capture`);
+    }
+    if (defaultDetectResources) {
+        ui.succeed(`Enabled Resource Detection`);
+    }
+    if (defaultExceptionCapture) {
+        ui.succeed(`Enabled Exception Capture`);
+    }
+    if (constants_1.DEFAULT_OTEL_LOG_LEVEL) {
+        ui.succeed(`Enable SDK Logger with Level "${constants_1.DEFAULT_OTEL_LOG_LEVEL}"`);
+    }
+    if (config.programmaticImports) {
+        ui.succeed(`Enabled Programmatic Imports`);
+    }
+    if (env.OTEL_PROPAGATORS) {
+        ui.succeed(`Using Propagators: "${env.OTEL_PROPAGATORS}"`);
+    }
+    if (env.OTEL_RESOURCE_ATTRIBUTES) {
+        ui.succeed(`Resource Attributes: "${env.OTEL_RESOURCE_ATTRIBUTES}"`);
+    }
+    if (env.OTEL_NODE_RESOURCE_DETECTORS) {
+        ui.succeed(`Resource Detectors: "${env.OTEL_NODE_RESOURCE_DETECTORS}"`);
+    }
+    if (constants_1.DEFAULT_OTEL_TRACES_SAMPLER) {
+        ui.succeed(`Traces Sampler: "${constants_1.DEFAULT_OTEL_TRACES_SAMPLER}"`);
+    }
+    if (defaultSentryIntegrationEnabled) {
+        ui.succeed(`Enabled Sentry Integration`);
+    }
+    if (stopOnTerminationSignals) {
+        ui.succeed('Enabled stopOnTerminationSignals');
+    }
+    else {
+        ui.warn('Disabled stopOnTerminationSignals (user is responsible for graceful shutdown on termination signals)');
+    }
+    if (defaultDisableLogs) {
+        ui.warn('Logs are disabled');
+    }
+    else {
+        ui.succeed(`Sending logs to "${_logger.getExporterUrl()}"`);
+    }
+    if (defaultDisableMetrics) {
+        ui.warn('Metrics are disabled');
+    }
+    else {
+        ui.succeed(`Sending metrics to "${constants_1.DEFAULT_OTEL_METRICS_EXPORTER_URL}"`);
+    }
+    if (defaultDisableTracing) {
+        ui.warn('Tracing is disabled');
+    }
+    else {
+        ui.succeed(`Sending traces to "${constants_1.DEFAULT_OTEL_TRACES_EXPORTER_URL}"`);
+    }
+    ui.stopAndPersist({
+        text: `OpenTelemetry SDK initialized successfully`,
+        symbol: '🦄',
+    });
+    if (!defaultDisableStartupLogs) {
+        setTimeout(() => {
+            const _targetUrl = `https://sophonz.com/services?service=${encodeURIComponent(defaultServiceName)}`;
+            ui.info(`
+
+View your app dashboard here:
+${_targetUrl}
+To disable these startup logs, set SOPHONZ_STARTUP_LOGS=false
+
+`);
+        }, 1000);
+    }
+};
+exports.initSDK = initSDK;
+const init = (config) => (0, exports.initSDK)({
+    consoleCapture: true,
+    experimentalExceptionCapture: true,
+    programmaticImports: true,
+    sentryIntegrationEnabled: true,
+    ...config,
+});
+exports.init = init;
+const _shutdown = () => {
+    var _a, _b;
+    const ui = (0, ora_1.default)({
+        spinner: cli_spinners_1.default.dots,
+        text: 'Shutting down OpenTelemetry SDK...',
+    }).start();
+    return ((_b = (_a = sdk === null || sdk === void 0 ? void 0 : sdk.shutdown()) === null || _a === void 0 ? void 0 : _a.then(() => {
+        ui.succeed('OpenTelemetry SDK shut down successfully');
+    }, (err) => {
+        ui.fail(`Error shutting down OpenTeLoader SDK: ${err}`);
+    })) !== null && _b !== void 0 ? _b : Promise.resolve());
+};
+const shutdown = () => {
+    api_1.diag.debug('shutdown() called');
+    return _shutdown();
+};
+exports.shutdown = shutdown;
+const setTraceAttributes = (attributes) => {
+    if (contextManager &&
+        typeof contextManager.getMutableContext === 'function') {
+        const mutableContext = contextManager.getMutableContext();
+        if (mutableContext != null) {
+            if (mutableContext.traceAttributes == null) {
+                mutableContext.traceAttributes = new Map();
+            }
+            for (const [k, v] of Object.entries(attributes)) {
+                mutableContext.traceAttributes.set(k, v);
+            }
+        }
+    }
+};
+exports.setTraceAttributes = setTraceAttributes;

package/build/src/spanProcessor.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
+import { BatchSpanProcessor, Span } from '@opentelemetry/sdk-trace-base';
+import type { MutableAsyncLocalStorageContextManager } from './MutableAsyncLocalStorageContextManager';
+export default class SophonzSpanProcessor extends BatchSpanProcessor {
+    private readonly enableSophonzGlobalContext;
+    private readonly contextManager;
+    constructor({ exporter, enableSophonzGlobalContext, contextManager, }: {
+        exporter: OTLPTraceExporter;
+        enableSophonzGlobalContext: boolean;
+        contextManager?: MutableAsyncLocalStorageContextManager;
+    });
+    private _setTraceAttributes;
+    onStart(_span: Span, _parentContext: Context): void;
+    onEnd(_span: Span): void;
+}
+//# sourceMappingURL=spanProcessor.d.ts.map

package/build/src/spanProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanProcessor.d.ts","sourceRoot":"","sources":["../../src/spanProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,0CAA0C,CAAC;AAEvG,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,kBAAkB;IAClE,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAU;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAEjB;gBAEF,EACV,QAAQ,EACR,0BAA0B,EAC1B,cAAc,GACf,EAAE;QACD,QAAQ,EAAE,iBAAiB,CAAC;QAC5B,0BAA0B,EAAE,OAAO,CAAC;QACpC,cAAc,CAAC,EAAE,sCAAsC,CAAC;KACzD;IAMD,OAAO,CAAC,mBAAmB;IAyB3B,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI;IAQnD,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI;CAYzB"}

package/build/src/spanProcessor.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+class SophonzSpanProcessor extends sdk_trace_base_1.BatchSpanProcessor {
+    constructor({ exporter, enableSophonzGlobalContext, contextManager, }) {
+        super(exporter);
+        this.enableSophonzGlobalContext = enableSophonzGlobalContext;
+        this.contextManager = contextManager;
+    }
+    _setTraceAttributes(span) {
+        if (this.enableSophonzGlobalContext &&
+            this.contextManager != null &&
+            typeof this.contextManager.getMutableContext === 'function') {
+            const spanAttributes = span.attributes;
+            const mutableContext = this.contextManager.getMutableContext();
+            const traceAttributes = mutableContext === null || mutableContext === void 0 ? void 0 : mutableContext.traceAttributes;
+            if (traceAttributes != null) {
+                traceAttributes.forEach((value, key) => {
+                    if (spanAttributes[key] == null) {
+                        span.setAttribute(key, value);
+                    }
+                });
+            }
+        }
+    }
+    onStart(_span, _parentContext) {
+        this._setTraceAttributes(_span);
+        super.onStart(_span, _parentContext);
+    }
+    onEnd(_span) {
+        _span._ended = false;
+        this._setTraceAttributes(_span);
+        _span._ended = true;
+        super.onEnd(_span);
+    }
+}
+exports.default = SophonzSpanProcessor;

package/build/src/tracing.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tracing.d.ts.map

package/build/src/tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/tracing.ts"],"names":[],"mappings":""}

package/build/src/tracing.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const otel_1 = require("./otel");
+(0, otel_1.initSDK)({});

package/build/src/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const jsonToString: (json: any) => string;
+export declare const stringToBoolean: (stringValue: string | undefined) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/build/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,GAAI,SAAI,WAQhC,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,aAAa,MAAM,GAAG,SAAS,YAe9D,CAAC"}

package/build/src/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringToBoolean = exports.jsonToString = void 0;
+const tslib_1 = require("tslib");
+const api_1 = require("@opentelemetry/api");
+const json_stringify_safe_1 = tslib_1.__importDefault(require("json-stringify-safe"));
+const jsonToString = (json) => {
+    try {
+        return JSON.stringify(json);
+    }
+    catch (ex) {
+        api_1.diag.debug(`Failed to stringify json. e = ${ex}`);
+        return (0, json_stringify_safe_1.default)(json);
+    }
+};
+exports.jsonToString = jsonToString;
+const stringToBoolean = (stringValue) => {
+    var _a;
+    switch ((_a = stringValue === null || stringValue === void 0 ? void 0 : stringValue.toLowerCase()) === null || _a === void 0 ? void 0 : _a.trim()) {
+        case 'true':
+        case 'yes':
+        case '1':
+            return true;
+        case 'false':
+        case 'no':
+        case '0':
+            return false;
+        default:
+            return undefined;
+    }
+};
+exports.stringToBoolean = stringToBoolean;

package/build/src/version.d.ts

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

package/build/src/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/build/src/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '0.0.1';

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@sophonz/node-sdk",
+  "version": "0.0.1",
+  "homepage": "https://sophonz.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sophonz-labs/sophonz-js.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.217.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.75.0",
+    "@opentelemetry/core": "^2.7.1",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.217.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.217.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.217.0",
+    "@opentelemetry/instrumentation": "^0.217.0",
+    "@opentelemetry/instrumentation-http": "^0.217.0",
+    "@opentelemetry/instrumentation-runtime-node": "^0.30.0",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.217.0",
+    "@opentelemetry/sdk-metrics": "^2.7.1",
+    "@opentelemetry/sdk-node": "^0.217.0",
+    "@opentelemetry/sdk-trace-base": "~2.7.1",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@sophonz/instrumentation-console": "*",
+    "@sophonz/instrumentation-node": "*",
+    "@sophonz/instrumentation-node-exception": "*",
+    "cli-spinners": "^3.4.0",
+    "json-stringify-safe": "^5.0.1",
+    "lodash.isobject": "^3.0.2",
+    "lodash.isplainobject": "^4.0.6",
+    "lodash.isstring": "^4.0.1",
+    "node-fetch": "^3.3.2",
+    "ora": "^9.4.0",
+    "pino-abstract-transport": "^3.0.0",
+    "semver": "^7.8.0",
+    "shimmer": "^1.2.1",
+    "tslib": "^2.8.1",
+    "winston": "^3.19.0",
+    "winston-transport": "^4.9.0"
+  },
+  "files": [
+    "build/*"
+  ],
+  "main": "build/src/index.js",
+  "bin": {
+    "opentelemetry-instrument": "build/bin/opentelemetry-instrument.js"
+  },
+  "types": "build/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/src/index.d.ts",
+      "require": "./build/src/index.js",
+      "default": "./build/src/index.js"
+    }
+  }
+}