@sophonz/node-sdk 0.0.1

package/build/src/instrumentations/console.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._parseConsoleArgs = void 0;
+const tslib_1 = require("tslib");
+const api_1 = tslib_1.__importStar(require("@opentelemetry/api"));
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const lodash_isobject_1 = tslib_1.__importDefault(require("lodash.isobject"));
+const lodash_isplainobject_1 = tslib_1.__importDefault(require("lodash.isplainobject"));
+const otel_logger_1 = require("../otel-logger");
+const winston_1 = require("../otel-logger/winston");
+const PACKAGE_NAME = '@sophonz/instrumentation-console';
+const PACKAGE_VERSION = '0.1.0';
+const _parseConsoleArgs = (args) => {
+    const stringifiedArgs = [];
+    let firstJson;
+    for (const arg of args) {
+        if ((0, lodash_isobject_1.default)(arg)) {
+            if (firstJson == null && (0, lodash_isplainobject_1.default)(arg)) {
+                firstJson = arg;
+            }
+            try {
+                const stringifiedArg = JSON.stringify(arg);
+                if (stringifiedArg != null) {
+                    stringifiedArgs.push(stringifiedArg);
+                }
+            }
+            catch (e) {
+                api_1.diag.error('Error stringifying console arg', e);
+            }
+        }
+        else {
+            stringifiedArgs.push(arg);
+        }
+    }
+    return firstJson
+        ? {
+            ...firstJson,
+            ...(args.length > 1 && { message: stringifiedArgs.join(' ') }),
+        }
+        : stringifiedArgs.join(' ');
+};
+exports._parseConsoleArgs = _parseConsoleArgs;
+class SophonzConsoleInstrumentation extends instrumentation_1.InstrumentationBase {
+    _patchConsole(type, ...args) {
+        var _a, _b;
+        const instrumentation = this;
+        const config = instrumentation.getConfig();
+        let level = type;
+        if (type === 'log') {
+            level = 'info';
+        }
+        try {
+            const parsedLog = (0, winston_1.parseWinstonLog)({
+                message: (0, exports._parseConsoleArgs)(args),
+                level,
+            });
+            const currentActiveSpan = api_1.default.trace.getActiveSpan();
+            const traceId = currentActiveSpan === null || currentActiveSpan === void 0 ? void 0 : currentActiveSpan.spanContext().traceId;
+            let meta = {
+                ...parsedLog.meta,
+                trace_id: traceId,
+                span_id: currentActiveSpan === null || currentActiveSpan === void 0 ? void 0 : currentActiveSpan.spanContext().spanId,
+            };
+            if (config.betaMode) {
+                if (this._contextManager != null &&
+                    typeof this._contextManager.getMutableContext === 'function') {
+                    meta = {
+                        ...meta,
+                        ...Object.fromEntries((_b = (_a = this._contextManager.getMutableContext()) === null || _a === void 0 ? void 0 : _a.traceAttributes) !== null && _b !== void 0 ? _b : []),
+                    };
+                }
+            }
+            instrumentation._hdxLogger.postMessage(parsedLog.level, parsedLog.message, meta);
+        }
+        catch (e) {
+            api_1.diag.error('Error processing console log', e);
+        }
+    }
+    _onPatch(moduleExports) {
+        this._wrap(moduleExports, 'debug', this._consoleDebugHandler);
+        this._wrap(moduleExports, 'log', this._consoleLogHandler);
+        this._wrap(moduleExports, 'info', this._consoleInfoHandler);
+        this._wrap(moduleExports, 'warn', this._consoleWarnHandler);
+        this._wrap(moduleExports, 'error', this._consoleErrorHandler);
+        return moduleExports;
+    }
+    _onUnPatch(moduleExports) {
+        this._unwrap(moduleExports, 'debug');
+        this._unwrap(moduleExports, 'log');
+        this._unwrap(moduleExports, 'info');
+        this._unwrap(moduleExports, 'warn');
+        this._unwrap(moduleExports, 'error');
+    }
+    constructor(config) {
+        super(PACKAGE_NAME, PACKAGE_VERSION, config);
+        this._consoleLogHandler = (original) => {
+            const instrumentation = this;
+            return (...args) => {
+                instrumentation._patchConsole('log', ...args);
+                return original.apply(this, args);
+            };
+        };
+        this._consoleInfoHandler = (original) => {
+            const instrumentation = this;
+            return (...args) => {
+                instrumentation._patchConsole('info', ...args);
+                return original.apply(this, args);
+            };
+        };
+        this._consoleWarnHandler = (original) => {
+            const instrumentation = this;
+            return (...args) => {
+                instrumentation._patchConsole('warn', ...args);
+                return original.apply(this, args);
+            };
+        };
+        this._consoleErrorHandler = (original) => {
+            const instrumentation = this;
+            return (...args) => {
+                instrumentation._patchConsole('error', ...args);
+                return original.apply(this, args);
+            };
+        };
+        this._consoleDebugHandler = (original) => {
+            const instrumentation = this;
+            return (...args) => {
+                instrumentation._patchConsole('debug', ...args);
+                return original.apply(this, args);
+            };
+        };
+        this._hdxLogger = new otel_logger_1.Logger(config.loggerOptions);
+        this._contextManager = config.contextManager;
+    }
+    init() {
+        return [
+            new instrumentation_1.InstrumentationNodeModuleDefinition('console', ['*'], (moduleExports) => {
+                this._onPatch(moduleExports);
+                return moduleExports;
+            }, (moduleExports) => {
+                this._onUnPatch(moduleExports);
+                return moduleExports;
+            }),
+        ];
+    }
+}
+exports.default = SophonzConsoleInstrumentation;

package/build/src/instrumentations/http.d.ts

@@ -0,0 +1,21 @@
+import { Span } from '@opentelemetry/api';
+import * as http from 'http';
+import { PassThrough, Readable } from 'stream';
+export declare const splitCommaSeparatedStrings: (headers?: string) => string[];
+export declare const getShouldRecordBody: (defaultFilter?: string) => (body: string) => boolean;
+export declare const interceptReadableStream: (stream: Readable, pt: PassThrough) => Readable;
+export declare const _handleHttpOutgoingClientRequest: (request: http.ClientRequest, span: Span, shouldRecordBody: (body: string) => boolean, httpCaptureHeadersClientRequest?: string) => void;
+export declare const _handleHttpIncomingServerRequest: (request: http.IncomingMessage, span: Span, shouldRecordBody: (body: string) => boolean, httpCaptureHeadersServerRequest?: string) => void;
+export declare const _handleHttpIncomingServerResponse: (response: http.ServerResponse, span: Span, shouldRecordBody: (body: string) => boolean, httpCaptureHeadersServerResponse?: string) => void;
+export declare const _handleHttpOutgoingClientResponse: (response: http.IncomingMessage, span: Span, shouldRecordBody: (body: string) => boolean, httpCaptureHeadersClientResponse?: string) => void;
+export declare const getSophonzHTTPInstrumentationConfig: ({ httpCaptureBodyKeywordsFilter, httpCaptureHeadersClientRequest, httpCaptureHeadersClientResponse, httpCaptureHeadersServerRequest, httpCaptureHeadersServerResponse, }: {
+    httpCaptureBodyKeywordsFilter?: string;
+    httpCaptureHeadersClientRequest?: string;
+    httpCaptureHeadersClientResponse?: string;
+    httpCaptureHeadersServerRequest?: string;
+    httpCaptureHeadersServerResponse?: string;
+}) => {
+    requestHook: (span: Span, request: http.ClientRequest | http.IncomingMessage) => void;
+    responseHook: (span: Span, response: http.ServerResponse | http.IncomingMessage) => void;
+};
+//# sourceMappingURL=http.d.ts.map

package/build/src/instrumentations/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../src/instrumentations/http.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AA4C/C,eAAO,MAAM,0BAA0B,GAAI,UAAU,MAAM,aACP,CAAC;AAErD,eAAO,MAAM,mBAAmB,GAC7B,gBAAgB,MAAM,MAAM,MAAM,MAAM,YAWxC,CAAC;AAEJ,eAAO,MAAM,uBAAuB,GAAI,QAAQ,QAAQ,EAAE,IAAI,WAAW,aASxE,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAC3C,SAAS,IAAI,CAAC,aAAa,EAC3B,MAAM,IAAI,EACV,kBAAkB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAC3C,kCAAkC,MAAM,SAyDzC,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAC3C,SAAS,IAAI,CAAC,eAAe,EAC7B,MAAM,IAAI,EACV,kBAAkB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAC3C,kCAAkC,MAAM,SA+CzC,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC5C,UAAU,IAAI,CAAC,cAAc,EAC7B,MAAM,IAAI,EACV,kBAAkB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAC3C,mCAAmC,MAAM,SAgE1C,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC5C,UAAU,IAAI,CAAC,eAAe,EAC9B,MAAM,IAAI,EACV,kBAAkB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAC3C,mCAAmC,MAAM,SAoD1C,CAAC;AAEF,eAAO,MAAM,mCAAmC,GAAI,0KAMjD;IACD,6BAA6B,CAAC,EAAE,MAAM,CAAC;IACvC,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,gCAAgC,CAAC,EAAE,MAAM,CAAC;IAC1C,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,gCAAgC,CAAC,EAAE,MAAM,CAAC;CAC3C;wBAIW,IAAI,WACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,eAAe;yBAqB5C,IAAI,YACA,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,eAAe;CAqBzD,CAAC"}

package/build/src/instrumentations/http.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSophonzHTTPInstrumentationConfig = exports._handleHttpOutgoingClientResponse = exports._handleHttpIncomingServerResponse = exports._handleHttpIncomingServerRequest = exports._handleHttpOutgoingClientRequest = exports.interceptReadableStream = exports.getShouldRecordBody = exports.splitCommaSeparatedStrings = void 0;
+const tslib_1 = require("tslib");
+const api_1 = require("@opentelemetry/api");
+const utils_1 = require("@opentelemetry/instrumentation-http/build/src/utils");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const http = tslib_1.__importStar(require("http"));
+const stream_1 = require("stream");
+const zlib_1 = tslib_1.__importDefault(require("zlib"));
+const SENSITIVE_DATA_SUBSTITUTE = '[Filtered]';
+const DEFAULT_DENYLIST = [
+    'password',
+    'passwd',
+    'secret',
+    'api_key',
+    'apikey',
+    'auth',
+    'credentials',
+    'mysql_pwd',
+    'privatekey',
+    'private_key',
+    'token',
+    'session',
+    'csrftoken',
+    'sessionid',
+    'x_csrftoken',
+    'set_cookie',
+    'cookie',
+    'authorization',
+    'x_api_key',
+    'aiohttp_session',
+    'connect.sid',
+    'csrf_token',
+    'csrf',
+    '_csrf',
+    '_csrf_token',
+    'PHPSESSID',
+    '_session',
+    'symfony',
+    'user_session',
+    '_xsrf',
+    'XSRF-TOKEN',
+];
+const splitCommaSeparatedStrings = (headers) => headers === null || headers === void 0 ? void 0 : headers.split(',').map((header) => header.trim());
+exports.splitCommaSeparatedStrings = splitCommaSeparatedStrings;
+const getShouldRecordBody = (defaultFilter) => (body) => {
+    var _a;
+    const lowerCaseBody = body.toLowerCase();
+    const keywords = (_a = (0, exports.splitCommaSeparatedStrings)(defaultFilter)) !== null && _a !== void 0 ? _a : DEFAULT_DENYLIST.map((keyword) => keyword.toLowerCase());
+    if (keywords === null || keywords === void 0 ? void 0 : keywords.some((keyword) => lowerCaseBody.includes(keyword))) {
+        return false;
+    }
+    return true;
+};
+exports.getShouldRecordBody = getShouldRecordBody;
+const interceptReadableStream = (stream, pt) => {
+    const originalState = stream.readableFlowing;
+    stream.pipe(pt);
+    stream.readableFlowing = originalState;
+    return stream;
+};
+exports.interceptReadableStream = interceptReadableStream;
+const _handleHttpOutgoingClientRequest = (request, span, shouldRecordBody, httpCaptureHeadersClientRequest) => {
+    var _a;
+    try {
+        const headers = (_a = (0, exports.splitCommaSeparatedStrings)(httpCaptureHeadersClientRequest)) !== null && _a !== void 0 ? _a : request.getRawHeaderNames();
+        span.setAttributes((0, utils_1.headerCapture)('request', headers, instrumentation_1.SemconvStability.OLD)((header) => request.getHeader(header)));
+    }
+    catch (e) {
+        api_1.diag.debug(`error parsing outgoing-request headers in requestHook: ${e}`);
+    }
+    const chunks = [];
+    const oldWrite = request.write.bind(request);
+    request.write = (data) => {
+        try {
+            if (typeof data === 'string') {
+                chunks.push(Buffer.from(data));
+            }
+            else {
+                chunks.push(data);
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in request.write: ${e}`);
+        }
+        return oldWrite(data);
+    };
+    const oldEnd = request.end.bind(request);
+    request.end = (data) => {
+        try {
+            if (data) {
+                if (typeof data === 'string') {
+                    chunks.push(Buffer.from(data));
+                }
+                else {
+                    chunks.push(data);
+                }
+            }
+            if (chunks.length > 0) {
+                const body = Buffer.concat(chunks).toString('utf8');
+                if (shouldRecordBody(body)) {
+                    span.setAttribute('http.request.body', body);
+                }
+                else {
+                    span.setAttribute('http.request.body', SENSITIVE_DATA_SUBSTITUTE);
+                }
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in request.end: ${e}`);
+        }
+        return oldEnd(data);
+    };
+};
+exports._handleHttpOutgoingClientRequest = _handleHttpOutgoingClientRequest;
+const _handleHttpIncomingServerRequest = (request, span, shouldRecordBody, httpCaptureHeadersServerRequest) => {
+    var _a;
+    try {
+        const headers = (_a = (0, exports.splitCommaSeparatedStrings)(httpCaptureHeadersServerRequest)) !== null && _a !== void 0 ? _a : request.headers;
+        span.setAttributes((0, utils_1.headerCapture)('request', Object.keys(headers), instrumentation_1.SemconvStability.OLD)((header) => headers[header]));
+    }
+    catch (e) {
+        api_1.diag.debug(`error parsing incoming-request headers in requestHook: ${e}`);
+    }
+    const chunks = [];
+    const pt = new stream_1.PassThrough();
+    pt.on('data', (chunk) => {
+        try {
+            if (typeof chunk === 'string') {
+                chunks.push(Buffer.from(chunk));
+            }
+            else {
+                chunks.push(chunk);
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in request.on('data'): ${e}`);
+        }
+    }).on('end', () => {
+        try {
+            if (chunks.length > 0) {
+                const body = Buffer.concat(chunks).toString('utf8');
+                if (shouldRecordBody(body)) {
+                    span.setAttribute('http.request.body', body);
+                }
+                else {
+                    span.setAttribute('http.request.body', SENSITIVE_DATA_SUBSTITUTE);
+                }
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in request.on('end'): ${e}`);
+        }
+    });
+    (0, exports.interceptReadableStream)(request, pt);
+};
+exports._handleHttpIncomingServerRequest = _handleHttpIncomingServerRequest;
+const _handleHttpIncomingServerResponse = (response, span, shouldRecordBody, httpCaptureHeadersServerResponse) => {
+    const chunks = [];
+    const oldWrite = response.write.bind(response);
+    response.write = (data) => {
+        try {
+            if (typeof data === 'string') {
+                chunks.push(Buffer.from(data));
+            }
+            else {
+                chunks.push(data);
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in response.write: ${e}`);
+        }
+        return oldWrite(data);
+    };
+    const oldEnd = response.end.bind(response);
+    response.end = (data) => {
+        var _a;
+        try {
+            if (data) {
+                if (typeof data === 'string') {
+                    chunks.push(Buffer.from(data));
+                }
+                else {
+                    chunks.push(data);
+                }
+            }
+            if (chunks.length > 0) {
+                const buffers = Buffer.concat(chunks);
+                let body = buffers.toString('utf8');
+                const isGzip = response.getHeader('content-encoding') === 'gzip';
+                if (isGzip) {
+                    body = zlib_1.default.gunzipSync(buffers).toString('utf8');
+                }
+                if (shouldRecordBody(body)) {
+                    span.setAttribute('http.response.body', body);
+                }
+                else {
+                    span.setAttribute('http.response.body', SENSITIVE_DATA_SUBSTITUTE);
+                }
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in response.end: ${e}`);
+        }
+        try {
+            const headers = (_a = (0, exports.splitCommaSeparatedStrings)(httpCaptureHeadersServerResponse)) !== null && _a !== void 0 ? _a : response.getHeaderNames();
+            span.setAttributes((0, utils_1.headerCapture)('response', headers, instrumentation_1.SemconvStability.OLD)((header) => response.getHeader(header)));
+        }
+        catch (e) {
+            api_1.diag.debug(`error parsing incoming-response headers in responseHook: ${e}`);
+        }
+        return oldEnd(data);
+    };
+};
+exports._handleHttpIncomingServerResponse = _handleHttpIncomingServerResponse;
+const _handleHttpOutgoingClientResponse = (response, span, shouldRecordBody, httpCaptureHeadersClientResponse) => {
+    var _a;
+    try {
+        const headers = (_a = (0, exports.splitCommaSeparatedStrings)(httpCaptureHeadersClientResponse)) !== null && _a !== void 0 ? _a : response.headers;
+        span.setAttributes((0, utils_1.headerCapture)('response', Object.keys(headers), instrumentation_1.SemconvStability.OLD)((header) => headers[header]));
+    }
+    catch (e) {
+        api_1.diag.debug(`error parsing outgoing-response headers in responseHook: ${e}`);
+    }
+    const chunks = [];
+    const pt = new stream_1.PassThrough();
+    pt.on('data', (chunk) => {
+        try {
+            if (typeof chunk === 'string') {
+                chunks.push(Buffer.from(chunk));
+            }
+            else {
+                chunks.push(chunk);
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in response.on('data'): ${e}`);
+        }
+    }).on('end', () => {
+        try {
+            if (chunks.length > 0) {
+                const buffers = Buffer.concat(chunks);
+                let body = buffers.toString('utf8');
+                const isGzip = response.headers['content-encoding'] === 'gzip';
+                if (isGzip) {
+                    body = zlib_1.default.gunzipSync(buffers).toString('utf8');
+                }
+                if (shouldRecordBody(body)) {
+                    span.setAttribute('http.response.body', body);
+                }
+                else {
+                    span.setAttribute('http.response.body', SENSITIVE_DATA_SUBSTITUTE);
+                }
+            }
+        }
+        catch (e) {
+            api_1.diag.debug(`error in response.on('end'): ${e}`);
+        }
+    });
+    (0, exports.interceptReadableStream)(response, pt);
+};
+exports._handleHttpOutgoingClientResponse = _handleHttpOutgoingClientResponse;
+const getSophonzHTTPInstrumentationConfig = ({ httpCaptureBodyKeywordsFilter, httpCaptureHeadersClientRequest, httpCaptureHeadersClientResponse, httpCaptureHeadersServerRequest, httpCaptureHeadersServerResponse, }) => {
+    const shouldRecordBody = (0, exports.getShouldRecordBody)(httpCaptureBodyKeywordsFilter);
+    return {
+        requestHook: (span, request) => {
+            if (request instanceof http.ClientRequest) {
+                (0, exports._handleHttpOutgoingClientRequest)(request, span, shouldRecordBody, httpCaptureHeadersClientRequest);
+            }
+            else {
+                (0, exports._handleHttpIncomingServerRequest)(request, span, shouldRecordBody, httpCaptureHeadersServerRequest);
+            }
+        },
+        responseHook: (span, response) => {
+            if (response instanceof http.ServerResponse) {
+                (0, exports._handleHttpIncomingServerResponse)(response, span, shouldRecordBody, httpCaptureHeadersServerResponse);
+            }
+            else {
+                (0, exports._handleHttpOutgoingClientResponse)(response, span, shouldRecordBody, httpCaptureHeadersClientResponse);
+            }
+        },
+    };
+};
+exports.getSophonzHTTPInstrumentationConfig = getSophonzHTTPInstrumentationConfig;

package/build/src/logger.d.ts

@@ -0,0 +1,26 @@
+import type { SophonzPinoOptions } from './otel-logger/pino';
+import type { SophonzWinstonOptions } from './otel-logger/winston';
+import SophonzWinston from './otel-logger/winston';
+type WinstonTransportOptions = Omit<SophonzWinstonOptions, 'apiKey' | 'getCustomMeta' | 'resourceAttributes'>;
+type PinotTransportOptions = Omit<SophonzPinoOptions, 'apiKey' | 'getCustomMeta' | 'resourceAttributes'>;
+export declare const getWinstonTransport: (maxLevel?: string, options?: WinstonTransportOptions) => SophonzWinston;
+export declare const getWinsonTransport: (maxLevel?: string, options?: WinstonTransportOptions) => SophonzWinston;
+export declare const getPinoMixinFunction: () => {
+    [x: string]: string;
+};
+export declare const getPinoTransport: (maxLevel?: string, options?: PinotTransportOptions) => {
+    target: string;
+    options: {
+        baseUrl?: string;
+        bufferSize?: number;
+        detectResource?: boolean;
+        headers: Record<string, string>;
+        queueSize?: number;
+        sendIntervalMs?: number;
+        service: string;
+        timeout?: number;
+    };
+    level: string;
+};
+export {};
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,cAAc,MAAM,uBAAuB,CAAC;AAEnD,KAAK,uBAAuB,GAAG,IAAI,CACjC,qBAAqB,EACrB,QAAQ,GAAG,eAAe,GAAG,oBAAoB,CAClD,CAAC;AAEF,KAAK,qBAAqB,GAAG,IAAI,CAC/B,kBAAkB,EAClB,QAAQ,GAAG,eAAe,GAAG,oBAAoB,CAClD,CAAC;AAeF,eAAO,MAAM,mBAAmB,GAC9B,iBAAiB,EACjB,UAAS,uBAA4B,mBAetC,CAAC;AAGF,eAAO,MAAM,kBAAkB,gCAlBpB,uBAAuB,mBAkBmB,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;CAA+B,CAAC;AACjE,eAAO,MAAM,gBAAgB,GAC3B,iBAAiB,EACjB,UAAS,qBAA0B;;;;;;;;;;;;;CAoBpC,CAAC"}

package/build/src/logger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPinoTransport = exports.getPinoMixinFunction = exports.getWinsonTransport = exports.getWinstonTransport = void 0;
+const tslib_1 = require("tslib");
+const api_1 = tslib_1.__importStar(require("@opentelemetry/api"));
+const constants_1 = require("./constants");
+const SophonzPino = tslib_1.__importStar(require("./otel-logger/pino"));
+const winston_1 = tslib_1.__importDefault(require("./otel-logger/winston"));
+const getCustomMeta = () => {
+    var _a;
+    const contextManager = (_a = api_1.default.context) === null || _a === void 0 ? void 0 : _a._getContextManager();
+    if (typeof (contextManager === null || contextManager === void 0 ? void 0 : contextManager.getMutableContext) === 'function') {
+        const mutableContext = contextManager.getMutableContext();
+        if ((mutableContext === null || mutableContext === void 0 ? void 0 : mutableContext.traceAttributes) != null) {
+            return Object.fromEntries(mutableContext.traceAttributes);
+        }
+    }
+    return {};
+};
+const getWinstonTransport = (maxLevel = 'info', options = {}) => {
+    api_1.diag.debug('Initializing winston transport');
+    const apiKey = (0, constants_1.DEFAULT_SOPHONZ_API_KEY)();
+    return new winston_1.default({
+        ...(apiKey && {
+            headers: {
+                Authorization: apiKey,
+            },
+        }),
+        maxLevel,
+        service: (0, constants_1.DEFAULT_SERVICE_NAME)(),
+        getCustomMeta: (0, constants_1.DEFAULT_SOPHONZ_NODE_BETA_MODE)() ? getCustomMeta : () => ({}),
+        ...options,
+    });
+};
+exports.getWinstonTransport = getWinstonTransport;
+exports.getWinsonTransport = exports.getWinstonTransport;
+exports.getPinoMixinFunction = SophonzPino.getMixinFunction;
+const getPinoTransport = (maxLevel = 'info', options = {}) => {
+    const apiKey = (0, constants_1.DEFAULT_SOPHONZ_API_KEY)();
+    return {
+        target: '@sophonz/node-sdk/build/src/otel-logger/pino',
+        options: {
+            ...(apiKey && {
+                headers: {
+                    Authorization: apiKey,
+                },
+            }),
+            service: (0, constants_1.DEFAULT_SERVICE_NAME)(),
+            ...options,
+        },
+        level: maxLevel,
+    };
+};
+exports.getPinoTransport = getPinoTransport;

package/build/src/metrics.d.ts

@@ -0,0 +1,3 @@
+import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+export declare const getSophonzMetricReader: () => PeriodicExportingMetricReader;
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../src/metrics.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAQ3E,eAAO,MAAM,sBAAsB,qCAO/B,CAAC"}

package/build/src/metrics.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSophonzMetricReader = void 0;
+const exporter_metrics_otlp_proto_1 = require("@opentelemetry/exporter-metrics-otlp-proto");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const constants_1 = require("./constants");
+const getSophonzMetricReader = () => new sdk_metrics_1.PeriodicExportingMetricReader({
+    exporter: new exporter_metrics_otlp_proto_1.OTLPMetricExporter({
+        url: constants_1.DEFAULT_OTEL_METRICS_EXPORTER_URL,
+    }),
+    exportIntervalMillis: constants_1.DEFAULT_OTEL_METRIC_EXPORT_INTERVAL,
+    exportTimeoutMillis: constants_1.DEFAULT_OTEL_METRIC_EXPORT_TIMEOUT,
+});
+exports.getSophonzMetricReader = getSophonzMetricReader;

package/build/src/otel-logger/index.d.ts

@@ -0,0 +1,36 @@
+import { Attributes } from '@opentelemetry/api';
+import { BatchLogRecordProcessor, LoggerProvider, LogRecordProcessor } from '@opentelemetry/sdk-logs';
+declare class NoopLogRecordProcessor implements LogRecordProcessor {
+    onEmit(): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export type LoggerOptions = {
+    baseUrl?: string;
+    bufferSize?: number;
+    detectResource?: boolean;
+    headers?: Record<string, string>;
+    queueSize?: number;
+    resourceAttributes?: Attributes;
+    sendIntervalMs?: number;
+    service?: string;
+    timeout?: number;
+};
+export declare class Logger {
+    private readonly _url;
+    private readonly logger;
+    private readonly processor;
+    private readonly provider;
+    constructor({ baseUrl, bufferSize, detectResource, headers, queueSize, resourceAttributes, sendIntervalMs, service, timeout, }: LoggerOptions);
+    private parseTimestamp;
+    isDisabled(): boolean;
+    setGlobalLoggerProvider(): void;
+    getExporterUrl(): string;
+    getProvider(): LoggerProvider;
+    getProcessor(): NoopLogRecordProcessor | BatchLogRecordProcessor;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+    postMessage(level: string, body: string, attributes?: Attributes): void;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/src/otel-logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/otel-logger/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAQ,MAAM,oBAAoB,CAAC;AAYtD,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAOjC,cAAM,sBAAuB,YAAW,kBAAkB;IACxD,MAAM,IAAI,IAAI;IAGd,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAG3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAG1B;AAcD,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,UAAU,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAE9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IAEpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmD;IAE7E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;gBAE9B,EACV,OAAO,EACP,UAAU,EACV,cAAqB,EACrB,OAAO,EACP,SAAS,EACT,kBAAkB,EAClB,cAAc,EACd,OAAO,EACP,OAAO,GACR,EAAE,aAAa;IAuDhB,OAAO,CAAC,cAAc;IAStB,UAAU;IAIV,uBAAuB;IAKvB,cAAc;IAId,WAAW;IAIX,YAAY;IAIZ,QAAQ;IAKR,UAAU;IAKV,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,GAAE,UAAe,GAAG,IAAI;CAW5E"}