@contrail/telemetry 1.1.0-alpha-frontend-logging-2 → 1.1.0-alpha-refactor-telemetry-2

package/CHANGELOG.md

@@ -7,10 +7,16 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.0.2] - 2026-03-25
+
+### Added
+
+- **Shared logger for libraries** — Any package can now `import { logger } from '@contrail/telemetry'` and get structured logging with request context, automatically enhanced when running inside a host service.
+- **Browser safety** — Safe to import in browser environments (no `process is not defined` errors).
+
 ### Changed
 
-- **Browser-safe**: `@contrail/telemetry` can now be imported in browser environments. Pino v10's built-in browser build provides the same `pino.Logger` interface backed by native `console.*` methods.
-- Libraries that previously had no logging can now `import { logger } from '@contrail/telemetry'` regardless of runtime environment.
+- Logger singleton now survives npm module duplication — no `overrides` needed for `@contrail/telemetry`.
 
 ## [1.0.0] - (initial changelog entry)
 

package/lib/index.d.ts

@@ -1 +1,2 @@
 export * from './logger';
+export * from './semantic-conventions';

package/lib/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./logger"), exports);
+__exportStar(require("./semantic-conventions"), exports);

package/lib/logger/flatten-object.d.ts

@@ -0,0 +1,4 @@
+type PrimitiveValue = string | number | boolean;
+type FlattenedObject = Record<string, PrimitiveValue>;
+export declare function flattenObject(obj: Record<string, unknown>): FlattenedObject;
+export {};

package/lib/logger/flatten-object.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenObject = flattenObject;
+const MAX_DEPTH = 10;
+function flattenObject(obj) {
+    const seen = new WeakSet();
+    return flattenRecursive(obj, '', seen, 0);
+}
+function flattenRecursive(obj, prefix, ancestors, depth) {
+    const result = {};
+    if (depth > MAX_DEPTH) {
+        result[prefix || 'value'] = '[max depth exceeded]';
+        return result;
+    }
+    ancestors.add(obj);
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (typeof value === 'object') {
+            if (ancestors.has(value)) {
+                result[fullKey] = '[circular reference]';
+                continue;
+            }
+            if (Array.isArray(value)) {
+                result[fullKey] = JSON.stringify(value);
+            }
+            else if (value instanceof Date) {
+                result[fullKey] = value.toISOString();
+            }
+            else if (value instanceof Error) {
+                result[fullKey] = value.message;
+                if (value.stack) {
+                    result[`${fullKey}.stack`] = value.stack;
+                }
+            }
+            else {
+                Object.assign(result, flattenRecursive(value, fullKey, ancestors, depth + 1));
+            }
+        }
+        else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            result[fullKey] = value;
+        }
+        else if (typeof value === 'bigint') {
+            result[fullKey] = value.toString();
+        }
+        else if (typeof value === 'symbol') {
+            result[fullKey] = value.toString();
+        }
+        else if (typeof value === 'function') {
+            result[fullKey] = '[function]';
+        }
+        else {
+            result[fullKey] = String(value);
+        }
+    }
+    ancestors.delete(obj);
+    return result;
+}

package/lib/logger/index.d.ts

@@ -1,3 +1,19 @@
 import pino from 'pino';
-export declare const logger: pino.Logger;
-export declare function setLogger(replacement: pino.Logger): void;
+export { parseOtelResourceAttributes } from './parse-otel-resource-attributes';
+export { PINO_LEVEL_TO_OTEL_SEVERITY, PINO_LEVEL_TO_NAME } from './logger-config';
+export { ATTR_LOG_MESSAGE, ATTR_LOG_PAYLOAD } from './semantic-conventions';
+export declare const baseLogger: pino.Logger<never, boolean>;
+export declare const logger: pino.Logger<never, boolean>;
+/**
+ * Add a stream destination to the logger's multistream.
+ * Use this to wire additional log sinks (e.g. InMemoryLogStream in app-framework).
+ */
+export declare function addStream(streamEntry: pino.StreamEntry): void;
+/**
+ * Flushes all pending logs to the OTLP collector.
+ * Call this at the end of Lambda handlers to ensure logs are delivered
+ * before the execution environment freezes.
+ */
+export declare function flushLogs(options?: {
+    timeoutMs?: number;
+}): Promise<void>;

package/lib/logger/index.js

@@ -2,20 +2,265 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a;
+var _a, _b, _c, _d, _e, _f, _g;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-exports.setLogger = setLogger;
+exports.logger = exports.baseLogger = exports.ATTR_LOG_PAYLOAD = exports.ATTR_LOG_MESSAGE = exports.PINO_LEVEL_TO_NAME = exports.PINO_LEVEL_TO_OTEL_SEVERITY = exports.parseOtelResourceAttributes = void 0;
+exports.addStream = addStream;
+exports.flushLogs = flushLogs;
 const pino_1 = __importDefault(require("pino"));
-const level = typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.LOG_LEVEL)
-    ? process.env.LOG_LEVEL
-    : 'debug';
-let _logger = (0, pino_1.default)({ level });
-exports.logger = new Proxy({}, {
-    get(_, prop) {
-        return Reflect.get(_logger, prop, _logger);
-    },
+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 core_1 = require("@opentelemetry/core");
+const resources_1 = require("@opentelemetry/resources");
+const api_1 = require("@opentelemetry/api");
+const stream_1 = require("stream");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const flatten_object_1 = require("./flatten-object");
+const logger_config_1 = require("./logger-config");
+const parse_otel_resource_attributes_1 = require("./parse-otel-resource-attributes");
+const semantic_conventions_2 = require("./semantic-conventions");
+const serverless_express_1 = require("@codegenie/serverless-express");
+var parse_otel_resource_attributes_2 = require("./parse-otel-resource-attributes");
+Object.defineProperty(exports, "parseOtelResourceAttributes", { enumerable: true, get: function () { return parse_otel_resource_attributes_2.parseOtelResourceAttributes; } });
+var logger_config_2 = require("./logger-config");
+Object.defineProperty(exports, "PINO_LEVEL_TO_OTEL_SEVERITY", { enumerable: true, get: function () { return logger_config_2.PINO_LEVEL_TO_OTEL_SEVERITY; } });
+Object.defineProperty(exports, "PINO_LEVEL_TO_NAME", { enumerable: true, get: function () { return logger_config_2.PINO_LEVEL_TO_NAME; } });
+var semantic_conventions_3 = require("./semantic-conventions");
+Object.defineProperty(exports, "ATTR_LOG_MESSAGE", { enumerable: true, get: function () { return semantic_conventions_3.ATTR_LOG_MESSAGE; } });
+Object.defineProperty(exports, "ATTR_LOG_PAYLOAD", { enumerable: true, get: function () { return semantic_conventions_3.ATTR_LOG_PAYLOAD; } });
+// --- Environment & Resource Setup ---
+const semantic_conventions_4 = require("../semantic-conventions");
+const LAMBDA_ENV_OTEL_ATTRIBUTES = getLambdaEnvAttributes();
+const isLocalEnvironment = process.env.LOCAL === 'true';
+const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+const shouldSendToOtlpCollector = Boolean(otlpEndpoint);
+const resourceAttributes = (0, parse_otel_resource_attributes_1.parseOtelResourceAttributes)();
+const resource = (0, resources_1.resourceFromAttributes)(resourceAttributes);
+const serviceName = (_b = (_a = resourceAttributes[semantic_conventions_1.ATTR_SERVICE_NAME]) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : 'unknown-service';
+const deploymentEnvironment = (_d = (_c = resourceAttributes[semantic_conventions_4.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : 'local';
+const serviceVersion = (_f = (_e = resourceAttributes[semantic_conventions_1.ATTR_SERVICE_VERSION]) === null || _e === void 0 ? void 0 : _e.toString()) !== null && _f !== void 0 ? _f : 'unknown';
+// --- OTel Log Provider ---
+const otelLoggerProvider = new sdk_logs_1.LoggerProvider({
+    resource,
+    processors: shouldSendToOtlpCollector ? [new sdk_logs_1.BatchLogRecordProcessor(new exporter_logs_otlp_http_1.OTLPLogExporter())] : [],
+});
+// Prevent OTel-internal errors (e.g. "Concurrent export limit reached") from routing back
+// through console.error → pino → OTel, which creates an unbounded async feedback loop.
+// Writing directly to process.stderr bypasses the hijacked console entirely.
+(0, core_1.setGlobalErrorHandler)((error) => {
+    var _a;
+    process.stderr.write(`[OTel Error] ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : String(error)}\n`);
 });
-function setLogger(replacement) {
-    _logger = replacement;
+const otelLogger = otelLoggerProvider.getLogger(serviceName);
+// --- Pino Stream Destinations ---
+function isPinoPrettyInstalled() {
+    try {
+        require.resolve('pino-pretty');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createStdoutStream() {
+    const shouldUsePrettyPrinting = isLocalEnvironment && isPinoPrettyInstalled();
+    if (shouldUsePrettyPrinting) {
+        // Use pino-pretty as a synchronous stream rather than a worker thread transport.
+        // pino.transport() hijacks the process stdout fd, which silently swallows
+        // console.log and output from other Pino instances.
+        const PinoPretty = require('pino-pretty');
+        return {
+            level: 'trace',
+            stream: PinoPretty({ colorize: true, sync: true }),
+        };
+    }
+    return {
+        level: 'trace',
+        stream: new stream_1.Writable({
+            write(chunk, _encoding, callback) {
+                var _a, _b, _c, _d;
+                let line;
+                try {
+                    const logRecord = JSON.parse(chunk.toString());
+                    const time = (_a = logRecord.time) !== null && _a !== void 0 ? _a : new Date().toISOString();
+                    const level = (_b = logger_config_1.PINO_LEVEL_TO_NAME[logRecord.level]) !== null && _b !== void 0 ? _b : 'INFO';
+                    const message = (_c = logRecord[semantic_conventions_2.ATTR_LOG_MESSAGE]) !== null && _c !== void 0 ? _c : '';
+                    const requestId = (_d = getLambdaRequestId()) !== null && _d !== void 0 ? _d : '-';
+                    const payload = logRecord[semantic_conventions_2.ATTR_LOG_PAYLOAD];
+                    const payloadLine = payload && typeof payload === 'object' && Object.keys(payload).length > 0
+                        ? `${JSON.stringify(payload, null, 2)}\n`
+                        : '';
+                    line = `${time}\t${requestId}\t${level}\t${message}\n${payloadLine}`;
+                }
+                catch {
+                    line = chunk.toString();
+                }
+                process.stdout.write(line);
+                callback();
+            },
+        }),
+    };
+}
+function createOtelStream() {
+    return new stream_1.Writable({
+        write(chunk, _encoding, callback) {
+            var _a, _b;
+            try {
+                const logRecord = JSON.parse(chunk.toString());
+                const { level, ...attributes } = logRecord;
+                const activeSpan = api_1.trace.getSpan(api_1.context.active());
+                const spanContext = activeSpan === null || activeSpan === void 0 ? void 0 : activeSpan.spanContext();
+                const spanAttributes = getSpanAttributes(activeSpan);
+                const lambdaEnvAttributes = LAMBDA_ENV_OTEL_ATTRIBUTES;
+                let safeAttributes;
+                try {
+                    safeAttributes = (0, flatten_object_1.flattenObject)(attributes);
+                }
+                catch {
+                    // Fallback in case flattening fails somehow. This is not expected.
+                    // If this happens, we will detect it by seeing structured objects
+                    // in our observability tooling instead of flat keys.
+                    safeAttributes = attributes;
+                }
+                otelLogger.emit({
+                    severityNumber: (_a = logger_config_1.PINO_LEVEL_TO_OTEL_SEVERITY[level]) !== null && _a !== void 0 ? _a : api_logs_1.SeverityNumber.INFO,
+                    severityText: (_b = logger_config_1.PINO_LEVEL_TO_NAME[level]) !== null && _b !== void 0 ? _b : 'INFO',
+                    body: attributes[semantic_conventions_2.ATTR_LOG_MESSAGE],
+                    // Attribute precedence (last-spread-wins):
+                    // 1. safeAttributes — flattened user/log-context attributes (lowest priority)
+                    // 2. lambdaEnvAttributes — static Lambda env attributes (override user attrs)
+                    // 3. spanAttributes — per-invocation span attributes like faas.*, cloud.*, aws.* (highest priority)
+                    // This is intentional: system-level attributes should always reflect the true runtime
+                    // environment, even if user code accidentally sets a conflicting key.
+                    attributes: {
+                        ...safeAttributes,
+                        ...lambdaEnvAttributes,
+                        ...spanAttributes,
+                    },
+                    ...(spanContext && {
+                        traceId: spanContext.traceId,
+                        spanId: spanContext.spanId,
+                    }),
+                });
+            }
+            catch (error) {
+                otelLogger.emit({
+                    severityNumber: api_logs_1.SeverityNumber.ERROR,
+                    severityText: 'ERROR',
+                    body: 'Failed to parse log record',
+                    attributes: {
+                        'log.raw': chunk.toString(),
+                        'error.message': error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+            callback();
+        },
+    });
+}
+function buildPinoStreams() {
+    const streams = [createStdoutStream()];
+    const shouldSendLogsToOtel = !isLocalEnvironment || otlpEndpoint;
+    if (shouldSendLogsToOtel) {
+        streams.push({ level: 'trace', stream: createOtelStream() });
+    }
+    return streams;
+}
+// --- Lambda Environment Attributes ---
+// Static attributes from Lambda environment variables (don't change per-invocation)
+function getLambdaEnvAttributes() {
+    const functionName = process.env.AWS_LAMBDA_FUNCTION_NAME;
+    if (!functionName)
+        return {};
+    const attributes = {
+        'faas.name': functionName,
+        'cloud.provider': 'aws',
+    };
+    if (process.env.AWS_LAMBDA_FUNCTION_VERSION) {
+        attributes['faas.version'] = process.env.AWS_LAMBDA_FUNCTION_VERSION;
+    }
+    if (process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE) {
+        attributes['faas.max_memory'] = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1024 * 1024;
+    }
+    if (process.env.AWS_REGION) {
+        attributes['cloud.region'] = process.env.AWS_REGION;
+    }
+    if (process.env.AWS_LAMBDA_LOG_STREAM_NAME) {
+        attributes['faas.instance'] = process.env.AWS_LAMBDA_LOG_STREAM_NAME;
+    }
+    return attributes;
+}
+// --- Span Attributes ---
+function isReadableSpan(span) {
+    return 'attributes' in span && typeof span.attributes === 'object';
+}
+function getSpanAttributes(span) {
+    if (!span || !span.isRecording())
+        return {};
+    if (!isReadableSpan(span))
+        return {};
+    const relevantPrefixes = ['faas.', 'cloud.', 'aws.'];
+    const result = {};
+    for (const [key, value] of Object.entries(span.attributes)) {
+        if (value !== undefined && relevantPrefixes.some((prefix) => key.startsWith(prefix))) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function getLambdaRequestId() {
+    try {
+        const { context: lambdaContext } = (0, serverless_express_1.getCurrentInvoke)();
+        return lambdaContext === null || lambdaContext === void 0 ? void 0 : lambdaContext.awsRequestId;
+    }
+    catch {
+        return undefined;
+    }
+}
+// --- Base Pino Logger ---
+exports.baseLogger = (0, pino_1.default)({
+    level: (_g = process.env.LOG_LEVEL) !== null && _g !== void 0 ? _g : 'debug',
+    messageKey: semantic_conventions_2.ATTR_LOG_MESSAGE,
+    timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    nestedKey: semantic_conventions_2.ATTR_LOG_PAYLOAD,
+    base: {
+        [semantic_conventions_1.ATTR_SERVICE_NAME]: serviceName,
+        [semantic_conventions_4.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: deploymentEnvironment,
+        [semantic_conventions_1.ATTR_SERVICE_VERSION]: serviceVersion,
+    },
+}, pino_1.default.multistream(buildPinoStreams()));
+exports.logger = exports.baseLogger;
+// --- Public API ---
+/**
+ * Add a stream destination to the logger's multistream.
+ * Use this to wire additional log sinks (e.g. InMemoryLogStream in app-framework).
+ */
+function addStream(streamEntry) {
+    const ms = exports.baseLogger.stream;
+    if (ms && typeof ms.add === 'function') {
+        ms.add(streamEntry);
+    }
+}
+/**
+ * Flushes all pending logs to the OTLP collector.
+ * Call this at the end of Lambda handlers to ensure logs are delivered
+ * before the execution environment freezes.
+ */
+async function flushLogs(options) {
+    var _a;
+    const timeoutMs = (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : 200;
+    try {
+        await Promise.race([
+            otelLoggerProvider.forceFlush(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Log flush timed out after ${timeoutMs}ms`)), timeoutMs)),
+        ]);
+    }
+    catch (error) {
+        console.error('[OTel Log Flush Failed]', JSON.stringify({
+            error: error instanceof Error ? error.message : String(error),
+            timeoutMs,
+            timestamp: new Date().toISOString(),
+        }));
+    }
 }

package/lib/logger/logger-config.d.ts

@@ -0,0 +1,3 @@
+import { SeverityNumber } from '@opentelemetry/api-logs';
+export declare const PINO_LEVEL_TO_OTEL_SEVERITY: Record<number, SeverityNumber>;
+export declare const PINO_LEVEL_TO_NAME: Record<number, string>;

package/lib/logger/logger-config.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PINO_LEVEL_TO_NAME = exports.PINO_LEVEL_TO_OTEL_SEVERITY = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+exports.PINO_LEVEL_TO_OTEL_SEVERITY = {
+    10: api_logs_1.SeverityNumber.TRACE,
+    20: api_logs_1.SeverityNumber.DEBUG,
+    30: api_logs_1.SeverityNumber.INFO,
+    40: api_logs_1.SeverityNumber.WARN,
+    50: api_logs_1.SeverityNumber.ERROR,
+    60: api_logs_1.SeverityNumber.FATAL,
+};
+exports.PINO_LEVEL_TO_NAME = {
+    10: 'TRACE',
+    20: 'DEBUG',
+    30: 'INFO',
+    40: 'WARN',
+    50: 'ERROR',
+    60: 'FATAL',
+};

package/lib/logger/parse-otel-resource-attributes.d.ts

@@ -0,0 +1,8 @@
+import { DetectedResourceAttributes } from '@opentelemetry/resources';
+/**
+ * Parse OTEL_RESOURCE_ATTRIBUTES environment variable manually since detectResources is async.
+ * Format: key1=value1,key2=value2
+ *
+ * Also checks OTEL_SERVICE_NAME which can be set separately.
+ */
+export declare function parseOtelResourceAttributes(resourceAttributesEnv?: string | undefined, serviceNameEnv?: string | undefined): DetectedResourceAttributes;

package/lib/logger/parse-otel-resource-attributes.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOtelResourceAttributes = parseOtelResourceAttributes;
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+/**
+ * Parse OTEL_RESOURCE_ATTRIBUTES environment variable manually since detectResources is async.
+ * Format: key1=value1,key2=value2
+ *
+ * Also checks OTEL_SERVICE_NAME which can be set separately.
+ */
+function parseOtelResourceAttributes(resourceAttributesEnv = process.env.OTEL_RESOURCE_ATTRIBUTES, serviceNameEnv = process.env.OTEL_SERVICE_NAME) {
+    const rawAttributes = resourceAttributesEnv || '';
+    const attributes = {};
+    if (rawAttributes) {
+        rawAttributes.split(',').forEach((pair) => {
+            const [key, ...valueParts] = pair.split('=');
+            if (key && valueParts.length > 0) {
+                attributes[key.trim()] = valueParts.join('=').trim();
+            }
+        });
+    }
+    // Also check OTEL_SERVICE_NAME which can be set separately
+    if (serviceNameEnv) {
+        attributes[semantic_conventions_1.ATTR_SERVICE_NAME] = serviceNameEnv;
+    }
+    return attributes;
+}

package/lib/logger/semantic-conventions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Log-specific semantic conventions.
+ */
+/**
+ * Attribute key for the log message body.
+ */
+export declare const ATTR_LOG_MESSAGE: "contrail.message";
+/**
+ * Attribute key for user-provided log payload objects.
+ */
+export declare const ATTR_LOG_PAYLOAD: "contrail.payload";

package/lib/logger/semantic-conventions.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Log-specific semantic conventions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTR_LOG_PAYLOAD = exports.ATTR_LOG_MESSAGE = void 0;
+/**
+ * Attribute key for the log message body.
+ */
+exports.ATTR_LOG_MESSAGE = 'contrail.message';
+/**
+ * Attribute key for user-provided log payload objects.
+ */
+exports.ATTR_LOG_PAYLOAD = 'contrail.payload';

package/lib/semantic-conventions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Semantic conventions for Contrail telemetry (logging + tracing).
+ *
+ * For attributes that ARE in the OpenTelemetry SDK (e.g. ATTR_CLIENT_ADDRESS, ATTR_HTTP_ROUTE),
+ * import directly from `@opentelemetry/semantic-conventions`.
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/
+ */
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/attributes-registry/user/
+ */
+export declare const ATTR_USER_ID: "user.id";
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/attributes-registry/user/
+ */
+export declare const ATTR_USER_EMAIL: "user.email";
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/attributes-registry/user/
+ */
+export declare const ATTR_USER_ROLES: "user.roles";
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/resource/deployment-environment/
+ */
+export declare const ATTR_DEPLOYMENT_ENVIRONMENT_NAME: "deployment.environment.name";
+/**
+ * Namespace for Contrail platform context.
+ */
+export declare const ATTR_CONTRAIL_SYSTEM: "contrail.system";
+/**
+ * Namespace for Contrail-custom user attributes (not in OTel spec).
+ */
+export declare const ATTR_CONTRAIL_USER: "contrail.user";

package/lib/semantic-conventions.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Semantic conventions for Contrail telemetry (logging + tracing).
+ *
+ * For attributes that ARE in the OpenTelemetry SDK (e.g. ATTR_CLIENT_ADDRESS, ATTR_HTTP_ROUTE),
+ * import directly from `@opentelemetry/semantic-conventions`.
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTR_CONTRAIL_USER = exports.ATTR_CONTRAIL_SYSTEM = exports.ATTR_DEPLOYMENT_ENVIRONMENT_NAME = exports.ATTR_USER_ROLES = exports.ATTR_USER_EMAIL = exports.ATTR_USER_ID = void 0;
+// ---------------------------------------------------------------------------
+// OTel-spec attributes not yet in the SDK
+// ---------------------------------------------------------------------------
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/attributes-registry/user/
+ */
+exports.ATTR_USER_ID = 'user.id';
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/attributes-registry/user/
+ */
+exports.ATTR_USER_EMAIL = 'user.email';
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/attributes-registry/user/
+ */
+exports.ATTR_USER_ROLES = 'user.roles';
+/**
+ * @see https://opentelemetry.io/docs/specs/semconv/resource/deployment-environment/
+ */
+exports.ATTR_DEPLOYMENT_ENVIRONMENT_NAME = 'deployment.environment.name';
+// ---------------------------------------------------------------------------
+// Contrail-custom attributes
+// ---------------------------------------------------------------------------
+/**
+ * Namespace for Contrail platform context.
+ */
+exports.ATTR_CONTRAIL_SYSTEM = 'contrail.system';
+/**
+ * Namespace for Contrail-custom user attributes (not in OTel spec).
+ */
+exports.ATTR_CONTRAIL_USER = 'contrail.user';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/telemetry",
-  "version": "1.1.0-alpha-frontend-logging-2",
+  "version": "1.1.0-alpha-refactor-telemetry-2",
   "description": "Telemetry and monitoring utilities for contrail services",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -14,9 +14,27 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@codegenie/serverless-express": "^4.16.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.211.0",
+    "@opentelemetry/core": "^2.5.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.211.0",
+    "@opentelemetry/resources": "^2.5.0",
+    "@opentelemetry/sdk-logs": "^0.211.0",
+    "@opentelemetry/sdk-trace-base": "^2.5.0",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.1.0"
   },
+  "peerDependencies": {
+    "pino-pretty": "^13.1.3"
+  },
+  "peerDependenciesMeta": {
+    "pino-pretty": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@types/aws-lambda": "^8.10.161",
     "@types/jest": "^29.5.2",
     "@types/node": "^20.0.0",
     "jest": "^29.5.0",