@unchainedshop/events 4.8.25 → 4.8.27

package/lib/audit/otlp-types.d.ts

@@ -0,0 +1,62 @@
+export type OTLPAnyValue = {
+    stringValue: string;
+} | {
+    boolValue: boolean;
+} | {
+    intValue: string;
+} | {
+    doubleValue: number;
+} | {
+    arrayValue: {
+        values: OTLPAnyValue[];
+    };
+} | {
+    kvlistValue: {
+        values: OTLPKeyValue[];
+    };
+};
+export interface OTLPKeyValue {
+    key: string;
+    value: OTLPAnyValue;
+}
+export interface OTLPResource {
+    attributes: OTLPKeyValue[];
+}
+export interface OTLPInstrumentationScope {
+    name: string;
+    version?: string;
+}
+export declare const OTLP_SEVERITY_NUMBER: {
+    readonly UNSPECIFIED: 0;
+    readonly INFO: 9;
+    readonly INFO2: 10;
+    readonly WARN: 13;
+    readonly ERROR: 17;
+    readonly FATAL: 21;
+    readonly FATAL4: 24;
+};
+export interface OTLPLogRecord {
+    timeUnixNano: string;
+    observedTimeUnixNano: string;
+    severityNumber: number;
+    severityText?: string;
+    body: OTLPAnyValue;
+    attributes: OTLPKeyValue[];
+}
+export interface OTLPScopeLogs {
+    scope: OTLPInstrumentationScope;
+    logRecords: OTLPLogRecord[];
+}
+export interface OTLPResourceLogs {
+    resource: OTLPResource;
+    scopeLogs: OTLPScopeLogs[];
+}
+export interface OTLPExportLogsServiceRequest {
+    resourceLogs: OTLPResourceLogs[];
+}
+export interface OTLPExportLogsServiceResponse {
+    partialSuccess?: {
+        rejectedLogRecords?: number | string;
+        errorMessage?: string;
+    };
+}

package/lib/audit/otlp-types.js

@@ -0,0 +1,9 @@
+export const OTLP_SEVERITY_NUMBER = {
+    UNSPECIFIED: 0,
+    INFO: 9,
+    INFO2: 10,
+    WARN: 13,
+    ERROR: 17,
+    FATAL: 21,
+    FATAL4: 24,
+};

package/lib/audit/otlp.d.ts

@@ -0,0 +1,9 @@
+import type { OCSFEvent } from './ocsf-types.ts';
+import { type OTLPAnyValue, type OTLPLogRecord, type OTLPExportLogsServiceRequest } from './otlp-types.ts';
+export declare function toAnyValue(value: unknown): OTLPAnyValue;
+export declare function encodeOCSFLogRecord(event: OCSFEvent, observedTimeMs: number): OTLPLogRecord;
+export declare function buildExportLogsRequest(events: OCSFEvent[], observedTimeMs?: number): OTLPExportLogsServiceRequest;
+export declare function parseOtlpHeaders(raw?: string): Record<string, string>;
+export declare function resolveCollectorUrl(explicit?: string): string | undefined;
+export declare function resolveCollectorHeaders(explicit?: Record<string, string>): Record<string, string>;
+export declare function exportLogs(collectorUrl: string, collectorHeaders: Record<string, string>, events: OCSFEvent[]): Promise<void>;

package/lib/audit/otlp.js

@@ -0,0 +1,164 @@
+import { createLogger } from '@unchainedshop/logger';
+import { OTLP_SEVERITY_NUMBER, } from "./otlp-types.js";
+const logger = createLogger('unchained:audit');
+const SEVERITY_NUMBER_MAP = {
+    0: OTLP_SEVERITY_NUMBER.UNSPECIFIED,
+    1: OTLP_SEVERITY_NUMBER.INFO,
+    2: OTLP_SEVERITY_NUMBER.INFO2,
+    3: OTLP_SEVERITY_NUMBER.WARN,
+    4: OTLP_SEVERITY_NUMBER.ERROR,
+    5: OTLP_SEVERITY_NUMBER.FATAL,
+    6: OTLP_SEVERITY_NUMBER.FATAL4,
+};
+const SEVERITY_TEXT_MAP = {
+    0: 'Unknown',
+    1: 'Informational',
+    2: 'Low',
+    3: 'Medium',
+    4: 'High',
+    5: 'Critical',
+    6: 'Fatal',
+};
+export function toAnyValue(value) {
+    if (typeof value === 'string')
+        return { stringValue: value };
+    if (typeof value === 'boolean')
+        return { boolValue: value };
+    if (typeof value === 'bigint')
+        return { intValue: value.toString() };
+    if (typeof value === 'number') {
+        return Number.isSafeInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+    }
+    if (Array.isArray(value))
+        return { arrayValue: { values: value.map(toAnyValue) } };
+    if (value !== null && typeof value === 'object') {
+        const values = [];
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === undefined)
+                continue;
+            values.push({ key, value: toAnyValue(entry) });
+        }
+        return { kvlistValue: { values } };
+    }
+    return { stringValue: String(value ?? null) };
+}
+function toMillisTimeUnixNano(timeMs) {
+    return (BigInt(Math.round(timeMs)) * 1000000n).toString();
+}
+export function encodeOCSFLogRecord(event, observedTimeMs) {
+    const attributes = [];
+    const attr = (key, value) => {
+        if (value === undefined)
+            return;
+        attributes.push({ key, value: toAnyValue(value) });
+    };
+    const user = event.user ?? event.actor?.user;
+    const sessionId = event.session?.uid ?? event.actor?.session?.uid;
+    attr('ocsf.class_uid', event.class_uid);
+    attr('ocsf.category_uid', event.category_uid);
+    attr('ocsf.activity_id', event.activity_id);
+    attr('ocsf.type_uid', event.type_uid);
+    attr('ocsf.severity_id', event.severity_id);
+    attr('ocsf.status_id', event.status_id);
+    attr('user.id', user?.uid);
+    attr('user.name', user?.name);
+    attr('client.address', event.src_endpoint?.ip);
+    attr('session.id', sessionId);
+    attr('ocsf.api.operation', event.api?.operation);
+    attr('log.record.uid', event.metadata.uid);
+    return {
+        timeUnixNano: toMillisTimeUnixNano(event.time),
+        observedTimeUnixNano: toMillisTimeUnixNano(observedTimeMs),
+        severityNumber: SEVERITY_NUMBER_MAP[event.severity_id] ?? OTLP_SEVERITY_NUMBER.UNSPECIFIED,
+        severityText: SEVERITY_TEXT_MAP[event.severity_id],
+        body: toAnyValue(event),
+        attributes,
+    };
+}
+export function buildExportLogsRequest(events, observedTimeMs = Date.now()) {
+    const resourceAttributes = [
+        {
+            key: 'service.name',
+            value: toAnyValue(process.env.OTEL_SERVICE_NAME || 'unchained-engine'),
+        },
+    ];
+    if (process.env.npm_package_version) {
+        resourceAttributes.push({
+            key: 'service.version',
+            value: toAnyValue(process.env.npm_package_version),
+        });
+    }
+    return {
+        resourceLogs: [
+            {
+                resource: { attributes: resourceAttributes },
+                scopeLogs: [
+                    {
+                        scope: { name: 'unchained:audit' },
+                        logRecords: events.map((event) => encodeOCSFLogRecord(event, observedTimeMs)),
+                    },
+                ],
+            },
+        ],
+    };
+}
+export function parseOtlpHeaders(raw) {
+    const headers = {};
+    if (!raw)
+        return headers;
+    for (const pair of raw.split(',')) {
+        const separatorIndex = pair.indexOf('=');
+        if (separatorIndex <= 0)
+            continue;
+        const key = pair.slice(0, separatorIndex).trim();
+        let value = pair.slice(separatorIndex + 1).trim();
+        try {
+            value = decodeURIComponent(value);
+        }
+        catch {
+        }
+        if (key)
+            headers[key] = value;
+    }
+    return headers;
+}
+export function resolveCollectorUrl(explicit) {
+    if (explicit)
+        return explicit;
+    if (process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
+        return process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
+    }
+    if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+        return `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT.replace(/\/+$/, '')}/v1/logs`;
+    }
+    return undefined;
+}
+export function resolveCollectorHeaders(explicit) {
+    return {
+        ...parseOtlpHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS),
+        ...parseOtlpHeaders(process.env.OTEL_EXPORTER_OTLP_LOGS_HEADERS),
+        ...explicit,
+    };
+}
+export async function exportLogs(collectorUrl, collectorHeaders, events) {
+    const response = await fetch(collectorUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...collectorHeaders,
+        },
+        body: JSON.stringify(buildExportLogsRequest(events)),
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    try {
+        const body = (await response.json());
+        const rejected = Number(body?.partialSuccess?.rejectedLogRecords || 0);
+        if (rejected > 0) {
+            logger.warn(`Collector rejected ${rejected} audit log records: ${body.partialSuccess?.errorMessage || 'unknown reason'}`);
+        }
+    }
+    catch {
+    }
+}

package/lib/audit/request-context.d.ts

@@ -0,0 +1,8 @@
+export interface AuditRequestContext {
+    userId?: string;
+    userName?: string;
+    remoteAddress?: string;
+    sessionId?: string;
+}
+export declare function runWithAuditContext<T>(context: AuditRequestContext, fn: () => T): T;
+export declare function getAuditContext(): AuditRequestContext | undefined;

package/lib/audit/request-context.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const asyncLocalStorage = new AsyncLocalStorage();
+export function runWithAuditContext(context, fn) {
+    return asyncLocalStorage.run(context, fn);
+}
+export function getAuditContext() {
+    return asyncLocalStorage.getStore();
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/events",
   "description": "Event emitter abstraction layer for the Unchained Engine",
-  "version": "4.8.25",
+  "version": "4.8.27",
   "main": "lib/events-index.js",
   "types": "lib/events-index.d.ts",
   "type": "module",
@@ -34,7 +34,7 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/logger": "^4.8.12"
+    "@unchainedshop/logger": "^4.8.27"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",