@omen.foundation/node-microservice-runtime 0.1.63 → 0.1.64

package/dist/logger.cjs

@@ -0,0 +1,480 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const pino_1 = __importStar(require("pino"));
+const node_stream_1 = require("node:stream");
+const node_module_1 = require("node:module");
+const env_js_1 = require("./env.js");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const collector_manager_js_1 = require("./collector-manager.js");
+function getRequire() {
+    if (typeof require !== 'undefined' && typeof require.main !== 'undefined') {
+        return require;
+    }
+    return (0, node_module_1.createRequire)(import.meta.url);
+}
+function shouldUsePrettyLogs() {
+    return process.env.IS_LOCAL === '1' || process.env.IS_LOCAL === 'true';
+}
+function mapPinoLevelToBeamableLevel(level) {
+    switch (level) {
+        case 10:
+            return 'Debug';
+        case 20:
+            return 'Debug';
+        case 30:
+            return 'Info';
+        case 40:
+            return 'Warning';
+        case 50:
+            return 'Error';
+        case 60:
+            return 'Fatal';
+        default:
+            return 'Info';
+    }
+}
+async function initializeOtlpLogging(serviceName, qualifiedServiceName, env, logger) {
+    const otlpEndpoint = process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT
+        || process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+        || (process.env.OTEL_EXPORTER_OTLP_ENDPOINT_LOGS ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT_LOGS : null);
+    const otlpProtocol = process.env.BEAM_OTEL_EXPORTER_OTLP_PROTOCOL
+        || process.env.OTEL_EXPORTER_OTLP_PROTOCOL
+        || process.env.OTEL_EXPORTER_OTLP_PROTOCOL_LOGS;
+    const isInDocker = process.env.IS_LOCAL !== '1' && process.env.IS_LOCAL !== 'true';
+    const useLocalOtel = !!process.env.BEAM_LOCAL_OTEL;
+    const standardOtelEnabled = (isInDocker || useLocalOtel) && !process.env.BEAM_DISABLE_STANDARD_OTEL;
+    if (!otlpEndpoint && !standardOtelEnabled) {
+        return Promise.resolve(null);
+    }
+    try {
+        const resourceAttributes = {};
+        if (serviceName) {
+            resourceAttributes['service.namespace'] = serviceName;
+            resourceAttributes['service.name'] = serviceName;
+        }
+        if (qualifiedServiceName) {
+            resourceAttributes['service.instance.id'] = qualifiedServiceName;
+        }
+        if (env === null || env === void 0 ? void 0 : env.cid) {
+            resourceAttributes['beam.cid'] = String(env.cid);
+        }
+        if (env === null || env === void 0 ? void 0 : env.pid) {
+            resourceAttributes['beam.pid'] = String(env.pid);
+        }
+        if (env === null || env === void 0 ? void 0 : env.routingKey) {
+            resourceAttributes['beam.routing_key'] = String(env.routingKey);
+        }
+        let endpointUrl = otlpEndpoint;
+        if (!endpointUrl && standardOtelEnabled && logger) {
+            try {
+                const discoveredEndpoint = await (0, collector_manager_js_1.discoverOrStartCollector)(logger, standardOtelEnabled, env);
+                if (discoveredEndpoint) {
+                    endpointUrl = discoveredEndpoint;
+                }
+                else {
+                    console.error('[OTLP] Standard OTLP is enabled but could not discover or start collector.');
+                    return Promise.resolve(null);
+                }
+            }
+            catch (error) {
+                console.error('[OTLP] Failed to discover/start collector:', error instanceof Error ? error.message : String(error));
+                return Promise.resolve(null);
+            }
+        }
+        if (!endpointUrl) {
+            if (standardOtelEnabled) {
+                console.error('[OTLP] Standard OTLP is enabled but no endpoint available. Set BEAM_OTEL_EXPORTER_OTLP_ENDPOINT to enable OTLP logging.');
+            }
+            return Promise.resolve(null);
+        }
+        let finalEndpointUrl = endpointUrl;
+        if (otlpProtocol && otlpProtocol.toLowerCase() === 'grpc') {
+            console.warn('[OTLP] Grpc protocol specified but not yet supported, using HTTP endpoint format');
+            finalEndpointUrl = endpointUrl.includes('/v1/logs')
+                ? endpointUrl
+                : `${endpointUrl.replace(/\/$/, '')}/v1/logs`;
+        }
+        else {
+            finalEndpointUrl = endpointUrl.includes('/v1/logs')
+                ? endpointUrl
+                : `${endpointUrl.replace(/\/$/, '')}/v1/logs`;
+        }
+        const exporterOptions = {
+            url: finalEndpointUrl,
+        };
+        if (otlpProtocol) {
+            const protocol = otlpProtocol.toLowerCase();
+            if (protocol === 'httpprotobuf' || protocol === 'protobuf') {
+                exporterOptions.contentType = 'application/x-protobuf';
+            }
+            else if (protocol === 'httpjson' || protocol === 'json') {
+                exporterOptions.contentType = 'application/json';
+            }
+            else if (protocol === 'grpc') {
+                console.warn('[OTLP] Grpc protocol is not yet supported in Node.js runtime, falling back to HttpProtobuf');
+                exporterOptions.contentType = 'application/x-protobuf';
+            }
+            else {
+                console.warn(`[OTLP] Unknown protocol "${otlpProtocol}", defaulting to HttpProtobuf`);
+                exporterOptions.contentType = 'application/x-protobuf';
+            }
+        }
+        else {
+            exporterOptions.contentType = 'application/x-protobuf';
+        }
+        if (process.env.BEAM_OTEL_EXPORTER_OTLP_HEADERS) {
+            exporterOptions.headers = JSON.parse(process.env.BEAM_OTEL_EXPORTER_OTLP_HEADERS);
+        }
+        const exporter = new exporter_logs_otlp_http_1.OTLPLogExporter(exporterOptions);
+        const baseResource = (0, resources_1.defaultResource)();
+        const customResource = (0, resources_1.resourceFromAttributes)(resourceAttributes);
+        const resource = baseResource.merge(customResource);
+        const processor = new sdk_logs_1.SimpleLogRecordProcessor(exporter);
+        const loggerProvider = new sdk_logs_1.LoggerProvider({
+            resource: resource,
+            processors: [processor],
+        });
+        api_logs_1.logs.setGlobalLoggerProvider(loggerProvider);
+        console.error(`[OTLP] OpenTelemetry logging initialized. Endpoint: ${finalEndpointUrl}, Service: ${serviceName || 'unknown'}`);
+        if (standardOtelEnabled && logger) {
+            try {
+                const { isCollectorRunning } = await Promise.resolve().then(() => __importStar(require('./collector-manager.js')));
+                for (let i = 0; i < 50; i++) {
+                    const status = await isCollectorRunning();
+                    if (status.isRunning && status.isReady) {
+                        if (logger) {
+                            logger.info(`[OTLP] Collector confirmed ready at ${status.otlpEndpoint || finalEndpointUrl}`);
+                        }
+                        break;
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+            catch (error) {
+                if (logger) {
+                    logger.warn(`[OTLP] Could not verify collector readiness: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        return Promise.resolve(loggerProvider);
+    }
+    catch (error) {
+        console.error('[OTLP] Failed to initialize OTLP logging:', error instanceof Error ? error.message : String(error));
+        if (error instanceof Error && error.stack) {
+            console.error('[OTLP] Stack trace:', error.stack);
+        }
+        return Promise.resolve(null);
+    }
+}
+function createBeamableLogFormatter(serviceName, qualifiedServiceName, otlpProviderRef) {
+    return new node_stream_1.Transform({
+        objectMode: false,
+        transform(chunk, _encoding, callback) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            try {
+                const line = buffer.toString('utf8');
+                if (!line.trim()) {
+                    callback();
+                    return;
+                }
+                const pinoLog = JSON.parse(line);
+                let timestamp;
+                if (typeof pinoLog.time === 'string') {
+                    timestamp = pinoLog.time;
+                }
+                else if (typeof pinoLog.time === 'number') {
+                    timestamp = new Date(pinoLog.time).toISOString();
+                }
+                else {
+                    timestamp = new Date().toISOString();
+                }
+                const level = mapPinoLevelToBeamableLevel(pinoLog.level);
+                const messageParts = [];
+                if (pinoLog.msg) {
+                    messageParts.push(pinoLog.msg);
+                }
+                if (pinoLog.err) {
+                    const err = pinoLog.err;
+                    const errMsg = err.message || err.msg || 'Error';
+                    const errStack = err.stack ? `\n${err.stack}` : '';
+                    messageParts.push(`${errMsg}${errStack}`);
+                }
+                const beamableLog = {
+                    __t: timestamp,
+                    __l: level,
+                    __m: messageParts.length > 0 ? messageParts.join(' ') : 'No message',
+                };
+                const contextFields = {};
+                if (pinoLog.cid)
+                    contextFields.cid = pinoLog.cid;
+                if (pinoLog.pid)
+                    contextFields.pid = pinoLog.pid;
+                if (pinoLog.routingKey)
+                    contextFields.routingKey = pinoLog.routingKey;
+                if (pinoLog.service)
+                    contextFields.service = pinoLog.service;
+                if (pinoLog.component)
+                    contextFields.component = pinoLog.component;
+                if (serviceName) {
+                    contextFields.serviceName = serviceName;
+                }
+                if (qualifiedServiceName) {
+                    contextFields.qualifiedServiceName = qualifiedServiceName;
+                }
+                const standardPinoFields = ['level', 'time', 'pid', 'hostname', 'name', 'msg', 'err', 'v', 'cid', 'pid', 'routingKey', 'sdkVersionExecution', 'service', 'component'];
+                for (const [key, value] of Object.entries(pinoLog)) {
+                    if (!standardPinoFields.includes(key) && value !== undefined && value !== null) {
+                        contextFields[key] = value;
+                    }
+                }
+                if (Object.keys(contextFields).length > 0) {
+                    beamableLog.__c = contextFields;
+                }
+                const otelFields = {};
+                const resourceAttributes = {};
+                if (serviceName) {
+                    resourceAttributes['service.namespace'] = serviceName;
+                    resourceAttributes['service.name'] = serviceName;
+                }
+                if (qualifiedServiceName) {
+                    resourceAttributes['service.qualifiedName'] = qualifiedServiceName;
+                }
+                if (pinoLog.cid) {
+                    resourceAttributes['beam.cid'] = String(pinoLog.cid);
+                }
+                if (pinoLog.pid) {
+                    resourceAttributes['beam.pid'] = String(pinoLog.pid);
+                }
+                if (pinoLog.routingKey) {
+                    resourceAttributes['beam.routing_key'] = String(pinoLog.routingKey);
+                }
+                const logAttributes = {};
+                if (pinoLog.component) {
+                    logAttributes['component'] = String(pinoLog.component);
+                }
+                if (pinoLog.err) {
+                    const err = pinoLog.err;
+                    if (err.message)
+                        logAttributes['exception.message'] = String(err.message);
+                    if (err.stack)
+                        logAttributes['exception.stacktrace'] = String(err.stack);
+                    if (err.type)
+                        logAttributes['exception.type'] = String(err.type);
+                }
+                const severityTextMap = {
+                    'Debug': 'Debug',
+                    'Info': 'Information',
+                    'Warning': 'Warning',
+                    'Error': 'Error',
+                    'Fatal': 'Critical',
+                };
+                const severityText = severityTextMap[level] || 'Information';
+                if (serviceName && !resourceAttributes['service.namespace']) {
+                    resourceAttributes['service.namespace'] = serviceName;
+                    resourceAttributes['service.name'] = serviceName;
+                }
+                otelFields['Timestamp'] = timestamp;
+                otelFields['SeverityText'] = severityText;
+                otelFields['Body'] = messageParts.length > 0 ? messageParts.join(' ') : 'No message';
+                otelFields['ResourceAttributes'] = resourceAttributes;
+                otelFields['LogAttributes'] = logAttributes;
+                Object.assign(beamableLog, otelFields);
+                if (otlpProviderRef === null || otlpProviderRef === void 0 ? void 0 : otlpProviderRef.provider) {
+                    try {
+                        const otlpLogger = otlpProviderRef.provider.getLogger(serviceName || 'beamable-node-runtime', undefined, {
+                            schemaUrl: undefined,
+                        });
+                        const severityNumberMap = {
+                            'Debug': 5,
+                            'Info': 9,
+                            'Warning': 13,
+                            'Error': 17,
+                            'Fatal': 21,
+                        };
+                        otlpLogger.emit({
+                            severityNumber: severityNumberMap[level] || 9,
+                            severityText: severityText,
+                            body: messageParts.length > 0 ? messageParts.join(' ') : 'No message',
+                            attributes: {
+                                ...logAttributes,
+                                ...(pinoLog.component ? { component: String(pinoLog.component) } : {}),
+                            },
+                            timestamp: new Date(timestamp).getTime() * 1000000,
+                            observedTimestamp: Date.now() * 1000000,
+                        });
+                    }
+                    catch (otlpError) {
+                    }
+                }
+                const output = JSON.stringify(beamableLog) + '\n';
+                callback(null, Buffer.from(output, 'utf8'));
+            }
+            catch (error) {
+                const fallbackLog = {
+                    __t: new Date().toISOString(),
+                    __l: 'Error',
+                    __m: `Failed to parse log entry: ${chunk.toString().substring(0, 200)}`,
+                };
+                callback(null, Buffer.from(JSON.stringify(fallbackLog) + '\n', 'utf8'));
+            }
+        },
+    });
+}
+function createLogger(env, options = {}) {
+    var _a, _b, _c;
+    const configuredDestination = (_a = options.destinationPath) !== null && _a !== void 0 ? _a : process.env.LOG_PATH;
+    const usePrettyLogs = shouldUsePrettyLogs();
+    const isInDocker = process.env.IS_LOCAL !== '1' && process.env.IS_LOCAL !== 'true';
+    const useLocalOtel = !!process.env.BEAM_LOCAL_OTEL;
+    const standardOtelEnabled = (isInDocker || useLocalOtel) && !process.env.BEAM_DISABLE_STANDARD_OTEL;
+    const otlpProviderRef = { provider: null };
+    if (options.otlpEndpoint) {
+        const originalEndpoint = process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT;
+        process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT = options.otlpEndpoint;
+        const initLogger = (0, pino_1.default)({
+            name: 'beamable-otlp-init',
+            level: 'info',
+        }, process.stdout);
+        initializeOtlpLogging(options.serviceName, options.qualifiedServiceName, env, initLogger).then((provider) => {
+            if (provider) {
+                otlpProviderRef.provider = provider;
+                initLogger.info(`[OTLP] OTLP provider created using existing collector at ${options.otlpEndpoint}`);
+                initLogger.info(`[OTLP] OpenTelemetry logging initialized. Endpoint: ${options.otlpEndpoint}/v1/logs, Service: ${options.serviceName || 'unknown'}`);
+            }
+            else {
+                initLogger.warn('[OTLP] OTLP provider creation returned null, structured logs will not be sent via OTLP');
+                otlpProviderRef.provider = null;
+            }
+        }).catch((error) => {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            initLogger.error(`[OTLP] Failed to create OTLP provider: ${errorMsg}`);
+            otlpProviderRef.provider = null;
+        });
+        if (originalEndpoint !== undefined) {
+            process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT = originalEndpoint;
+        }
+        else {
+            delete process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT;
+        }
+    }
+    else {
+        otlpProviderRef.provider = null;
+        if (standardOtelEnabled) {
+            (async () => {
+                const bgLogger = (0, pino_1.default)({ name: 'beamable-otlp-bg', level: 'info' }, process.stdout);
+                const maxAttempts = 30;
+                const checkInterval = 1000;
+                for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                    try {
+                        const { isCollectorRunning } = await Promise.resolve().then(() => __importStar(require('./collector-manager.js')));
+                        const collectorStatus = await isCollectorRunning();
+                        if (collectorStatus.isRunning && collectorStatus.isReady && collectorStatus.otlpEndpoint) {
+                            const endpoint = collectorStatus.otlpEndpoint.startsWith('http')
+                                ? collectorStatus.otlpEndpoint
+                                : `http://${collectorStatus.otlpEndpoint}`;
+                            const newProvider = await initializeOtlpLogging(options.serviceName, options.qualifiedServiceName, env, bgLogger);
+                            if (newProvider) {
+                                otlpProviderRef.provider = newProvider;
+                                console.error(`[OTLP] Connected to collector at ${endpoint} (background connection)`);
+                                break;
+                            }
+                        }
+                    }
+                    catch (error) {
+                    }
+                    if (attempt < maxAttempts - 1) {
+                        await new Promise(resolve => setTimeout(resolve, checkInterval));
+                    }
+                }
+            })();
+        }
+    }
+    const pinoOptions = {
+        name: (_b = options.name) !== null && _b !== void 0 ? _b : 'beamable-node-runtime',
+        level: env.logLevel,
+        base: {
+            cid: env.cid,
+            pid: env.pid,
+            routingKey: (_c = env.routingKey) !== null && _c !== void 0 ? _c : null,
+            sdkVersionExecution: env.sdkVersionExecution,
+            serviceName: options.serviceName,
+            qualifiedServiceName: options.qualifiedServiceName,
+        },
+        redact: {
+            paths: ['secret', 'refreshToken'],
+            censor: '***',
+        },
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    };
+    if (!configuredDestination || configuredDestination === '-' || configuredDestination === 'stdout' || configuredDestination === 'console') {
+        if (!usePrettyLogs) {
+            const beamableFormatter = createBeamableLogFormatter(options.serviceName, options.qualifiedServiceName, otlpProviderRef);
+            beamableFormatter.pipe(process.stdout);
+            return (0, pino_1.default)(pinoOptions, beamableFormatter);
+        }
+        else {
+            try {
+                const requireFn = getRequire();
+                const pinoPretty = requireFn('pino-pretty');
+                const prettyStream = pinoPretty({
+                    colorize: true,
+                    translateTime: 'HH:MM:ss.l',
+                    ignore: 'pid,hostname',
+                    singleLine: false,
+                });
+                return (0, pino_1.default)(pinoOptions, prettyStream);
+            }
+            catch {
+                return (0, pino_1.default)(pinoOptions, process.stdout);
+            }
+        }
+    }
+    const resolvedDestination = configuredDestination === 'temp' ? (0, env_js_1.ensureWritableTempDirectory)() : configuredDestination;
+    if (!usePrettyLogs) {
+        const beamableFormatter = createBeamableLogFormatter(options.serviceName, options.qualifiedServiceName, otlpProviderRef);
+        const fileStream = (0, pino_1.destination)({ dest: resolvedDestination, mkdir: true, append: true, sync: false });
+        beamableFormatter.pipe(fileStream);
+        return (0, pino_1.default)(pinoOptions, beamableFormatter);
+    }
+    else {
+        const fileStream = (0, pino_1.destination)({ dest: resolvedDestination, mkdir: true, append: true, sync: false });
+        return (0, pino_1.default)(pinoOptions, fileStream);
+    }
+}

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAa,EAAe,KAAK,MAAM,EAAsB,MAAM,MAAM,CAAC;AAI1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAiCpD,UAAU,oBAAoB;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA8eD,wBAAgB,YAAY,CAAC,GAAG,EAAE,iBAAiB,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,CAgN/F"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAa,EAAe,KAAK,MAAM,EAAsB,MAAM,MAAM,CAAC;AAI1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAiCpD,UAAU,oBAAoB;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA8eD,wBAAgB,YAAY,CAAC,GAAG,EAAE,iBAAiB,EAAE,OAAO,GAAE,oBAAyB,GAAG,MAAM,CA6L/F"}

package/dist/logger.js

@@ -501,42 +501,26 @@ export function createLogger(env, options = {}) {
             name: 'beamable-otlp-init',
             level: 'info',
         }, process.stdout);
-        // Create provider synchronously - since endpoint is explicitly provided,
-        // initializeOtlpLogging will skip discovery and create provider directly
-        let provider = null;
-        let completed = false;
-        initializeOtlpLogging(options.serviceName, options.qualifiedServiceName, env, initLogger).then((result) => {
-            provider = result;
-            completed = true;
-            if (result) {
+        // Create OTLP provider asynchronously (non-blocking)
+        // Since endpoint is explicitly provided and collector is already ready,
+        // this should complete quickly, but we don't block for it
+        initializeOtlpLogging(options.serviceName, options.qualifiedServiceName, env, initLogger).then((provider) => {
+            if (provider) {
+                otlpProviderRef.provider = provider;
                 initLogger.info(`[OTLP] OTLP provider created using existing collector at ${options.otlpEndpoint}`);
+                initLogger.info(`[OTLP] OpenTelemetry logging initialized. Endpoint: ${options.otlpEndpoint}/v1/logs, Service: ${options.serviceName || 'unknown'}`);
             }
-        }).catch((error) => {
-            initLogger.error(`[OTLP] Failed to create OTLP provider: ${error instanceof Error ? error.message : String(error)}`);
-            completed = true;
-            provider = null;
-        });
-        // Wait briefly for provider creation (should be very fast, < 1 second)
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const deasync = require('deasync');
-        const startTime = Date.now();
-        const timeout = 2000; // 2 second timeout (should be fast since no discovery needed)
-        deasync.loopWhile(() => {
-            if (Date.now() - startTime >= timeout) {
-                return false;
+            else {
+                initLogger.warn('[OTLP] OTLP provider creation returned null, structured logs will not be sent via OTLP');
+                otlpProviderRef.provider = null;
             }
-            return !completed;
-        });
-        // CRITICAL: Only set provider if it was successfully created
-        // This ensures structured logs are only created when OTLP is ready
-        if (provider) {
-            otlpProviderRef.provider = provider;
-            initLogger.info(`[OTLP] OpenTelemetry logging initialized. Endpoint: ${options.otlpEndpoint}/v1/logs, Service: ${options.serviceName || 'unknown'}`);
-        }
-        else {
-            initLogger.warn('[OTLP] OTLP provider creation failed, structured logs will not be sent via OTLP');
+        }).catch((error) => {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            initLogger.error(`[OTLP] Failed to create OTLP provider: ${errorMsg}`);
             otlpProviderRef.provider = null;
-        }
+        });
+        // Don't wait - logger will work immediately with console output,
+        // and OTLP will be added when the provider is ready (very quickly since collector is already running)
         // Restore original endpoint if it existed
         if (originalEndpoint !== undefined) {
             process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT = originalEndpoint;