@omen.foundation/node-microservice-runtime 0.1.76 → 0.1.77

package/dist/logger.cjs

@@ -0,0 +1,545 @@
+"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 initializeBetterStackLogging(serviceName, qualifiedServiceName, env) {
+    const betterStackEnabled = process.env.BEAM_BETTERSTACK_ENABLED === 'true' ||
+        process.env.BEAM_BETTERSTACK_ENABLED === '1';
+    if (!betterStackEnabled) {
+        return Promise.resolve(null);
+    }
+    const betterStackToken = process.env.BEAM_BETTERSTACK_TOKEN || process.env.BETTERSTACK_TOKEN;
+    const betterStackEndpoint = process.env.BEAM_BETTERSTACK_ENDPOINT ||
+        process.env.BETTERSTACK_ENDPOINT ||
+        'https://in.logs.betterstack.com';
+    if (!betterStackToken) {
+        console.warn('[BetterStack] BetterStack logging is enabled but BEAM_BETTERSTACK_TOKEN is not set. Skipping BetterStack logging.');
+        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);
+        }
+        const endpointUrl = betterStackEndpoint.includes('/v1/logs')
+            ? betterStackEndpoint
+            : `${betterStackEndpoint.replace(/\/$/, '')}/v1/logs`;
+        const exporterOptions = {
+            url: endpointUrl,
+            headers: {
+                'Authorization': `Bearer ${betterStackToken}`,
+            },
+            contentType: 'application/json',
+        };
+        const exporter = new exporter_logs_otlp_http_1.OTLPLogExporter(exporterOptions);
+        console.error(`[BetterStack] BetterStack logging initialized. Endpoint: ${endpointUrl}, Service: ${serviceName || 'unknown'}`);
+        return Promise.resolve(exporter);
+    }
+    catch (error) {
+        console.error('[BetterStack] Failed to initialize BetterStack logging:', error instanceof Error ? error.message : String(error));
+        if (error instanceof Error && error.stack) {
+            console.error('[BetterStack] Stack trace:', error.stack);
+        }
+        return Promise.resolve(null);
+    }
+}
+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 processors = [new sdk_logs_1.BatchLogRecordProcessor(exporter)];
+        try {
+            const betterStackExporter = await initializeBetterStackLogging(serviceName, qualifiedServiceName, env);
+            if (betterStackExporter) {
+                processors.push(new sdk_logs_1.BatchLogRecordProcessor(betterStackExporter));
+                console.error('[BetterStack] BetterStack exporter added as second processor - logs will be sent to both ClickHouse and BetterStack');
+            }
+        }
+        catch (error) {
+            console.warn('[BetterStack] Failed to initialize BetterStack exporter (continuing without it):', error instanceof Error ? error.message : String(error));
+        }
+        const loggerProvider = new sdk_logs_1.LoggerProvider({
+            resource: resource,
+            processors: processors,
+        });
+        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) {
+                        console.error(`[OTLP] Failed to emit log record via OTLP: ${otlpError instanceof Error ? otlpError.message : String(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/message.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allocateRequestId = allocateRequestId;
+exports.serializeGatewayRequest = serializeGatewayRequest;
+exports.deserializeGatewayResponse = deserializeGatewayResponse;
+let nextRequestId = -1;
+function allocateRequestId() {
+    nextRequestId -= 1;
+    if (nextRequestId < -9000000000) {
+        nextRequestId = -1;
+    }
+    return nextRequestId;
+}
+function serializeGatewayRequest(request) {
+    return JSON.stringify(request);
+}
+function deserializeGatewayResponse(raw) {
+    return JSON.parse(raw);
+}

package/dist/requester.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayRequester = void 0;
+const node_events_1 = require("node:events");
+const errors_js_1 = require("./errors.js");
+const message_js_1 = require("./message.js");
+class GatewayRequester {
+    constructor(socket, logger) {
+        this.pending = new Map();
+        this.emitter = new node_events_1.EventEmitter();
+        this.requestTimeoutMs = 15000;
+        this.socket = socket;
+        this.logger = logger.child({ component: 'GatewayRequester' });
+        this.socket.on('message', (...args) => { var _a; return this.onRawMessage(String((_a = args[0]) !== null && _a !== void 0 ? _a : '')); });
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+    }
+    setRequestTimeout(timeoutMs) {
+        this.requestTimeoutMs = timeoutMs;
+    }
+    async request(method, path, body) {
+        const id = (0, message_js_1.allocateRequestId)();
+        const effectiveBody = body !== null && body !== void 0 ? body : {};
+        const request = {
+            id,
+            method: method.toLowerCase(),
+            path,
+            body: effectiveBody,
+        };
+        this.logger.debug({ id, method, path, body: effectiveBody }, 'Sending gateway request.');
+        const payload = (0, message_js_1.serializeGatewayRequest)(request);
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new errors_js_1.TimeoutError(`Request ${method} ${path} timed out after ${this.requestTimeoutMs}ms`));
+            }, this.requestTimeoutMs).unref();
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+                timeoutHandle,
+                path,
+                method,
+            });
+            this.socket
+                .send(payload)
+                .catch((error) => {
+                clearTimeout(timeoutHandle);
+                this.pending.delete(id);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    }
+    async sendResponse(response) {
+        const payload = JSON.stringify(response);
+        await this.socket.send(payload);
+    }
+    async acknowledge(id, status = 200) {
+        await this.sendResponse({ id, status, body: null });
+    }
+    onRawMessage(raw) {
+        this.logger.debug({ raw }, 'Received websocket frame.');
+        let envelope;
+        try {
+            envelope = (0, message_js_1.deserializeGatewayResponse)(raw);
+        }
+        catch (error) {
+            this.logger.error({ err: error, raw }, 'Failed to parse gateway message.');
+            return;
+        }
+        if (typeof envelope.id !== 'number') {
+            this.logger.warn({ envelope }, 'Invalid gateway message without id.');
+            return;
+        }
+        const pending = this.pending.get(envelope.id);
+        if (pending) {
+            clearTimeout(pending.timeoutHandle);
+            this.pending.delete(envelope.id);
+            if ('status' in envelope && envelope.status === 403) {
+                pending.reject(new errors_js_1.AuthenticationError('Gateway rejected the request with 403.'));
+                return;
+            }
+            pending.resolve(envelope.body);
+            return;
+        }
+        this.emitter.emit('event', envelope);
+    }
+    dispose() {
+        for (const [id, pending] of this.pending.entries()) {
+            clearTimeout(pending.timeoutHandle);
+            pending.reject(new Error(`Request ${pending.method} ${pending.path} cancelled during shutdown.`));
+            this.pending.delete(id);
+        }
+        this.emitter.removeAllListeners();
+    }
+}
+exports.GatewayRequester = GatewayRequester;