@riddance/host 0.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright © 2022 The Riddance Authors (see git commits)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/context.d.ts

@@ -0,0 +1,93 @@
+export interface Environment {
+    readonly [key: string]: string;
+}
+export interface Logger {
+    enrich(fields: object): Logger;
+    trace(message: string, error?: unknown, fields?: object): void;
+    debug(message: string, error?: unknown, fields?: object): void;
+    info(message: string, error?: unknown, fields?: object): void;
+    warn(message: string, error?: unknown, fields?: object): void;
+    error(message: string, error?: unknown, fields?: object): void;
+    fatal(message: string, error?: unknown, fields?: object): void;
+}
+export interface AbortSignal {
+    aborted: boolean;
+    addEventListener: (type: 'abort', listener: (this: AbortSignal, event: unknown) => unknown, options?: {
+        capture?: boolean;
+        once?: boolean;
+        passive?: boolean;
+    }) => void;
+    removeEventListener: (type: 'abort', listener: (this: AbortSignal, event: unknown) => unknown, options?: {
+        capture?: boolean;
+    }) => void;
+}
+export declare type MutableJson = null | boolean | number | string | MutableJson[] | {
+    [key: string]: MutableJson;
+};
+export declare type Json = null | boolean | number | string | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+export declare function objectSpreadable(json?: Json): {
+    readonly [key: string]: Json;
+};
+export declare function arraySpreadable(json?: Json): readonly Json[];
+export interface HandlerConfiguration {
+    /**
+     * An indication of CPU usage of the handler.
+     * @default 'low'
+     */
+    readonly compute?: 'high' | 'low';
+    /**
+     * An indication of memory usage of the handler.
+     * @default 'low'
+     */
+    readonly memory?: 'high' | 'low';
+    /**
+     * A boolean indicating whether to enrich the log with the body of events, requests or responses. Set to false if the body is large or contain very sensitive data.
+     * @default false
+     */
+    readonly excludeBodyFromLogs?: boolean;
+    /**
+     * The level below which log entries will be discarded.
+     * @default 'trace'
+     */
+    readonly minimumLogLevel?: 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal';
+    /**
+     * The number of seconds the function is expected to finish executing in.
+     */
+    readonly timeout?: number;
+}
+export interface Context {
+    readonly env: Environment;
+    readonly log: Logger;
+    readonly signal: AbortSignal;
+    now(): Date;
+    readonly operationId?: string;
+    readonly client?: {
+        readonly id?: string;
+        readonly ip?: string;
+        readonly port?: number;
+        readonly userAgent?: string;
+    };
+    readonly meta?: {
+        readonly packageName: string;
+        readonly fileName: string;
+        readonly revision?: string;
+    };
+    emit(topic: string, type: string, subject: string, data?: Json, messageId?: string): void;
+    eventBarrier(): Promise<void>;
+    onSuccess(fn: () => Promise<void> | void): void;
+}
+export declare function httpRequestHeaders(context: Context): {
+    [key: string]: string;
+};
+export declare function throwOnNotOK<T extends {
+    ok?: boolean;
+    status?: number;
+    text?: () => Promise<string>;
+}>(response: T, message: string, data?: {
+    [key: string]: unknown;
+}): Promise<T>;
+export declare function measure<T>(logger: {
+    trace: (message: string, _: undefined, f: object) => void;
+}, name: string, fn: () => Promise<T> | T, fields?: object): Promise<T>;

package/context.js

@@ -0,0 +1,70 @@
+import { performance } from 'perf_hooks';
+import { highPrecisionISODate } from './host/logging.js';
+/*@__INLINE__*/
+export function objectSpreadable(json) {
+    if (!json) {
+        return {};
+    }
+    return json;
+}
+/*@__INLINE__*/
+export function arraySpreadable(json) {
+    if (!Array.isArray(json)) {
+        return [];
+    }
+    return json;
+}
+export function httpRequestHeaders(context) {
+    const headers = {
+        'user-agent': `${context.meta?.packageName ?? '?'}/${context.meta?.revision ?? '?'}`,
+    };
+    if (context.operationId) {
+        headers['x-request-id'] = context.operationId;
+    }
+    if (context.client) {
+        if (context.client.id) {
+            headers['x-client-id'] = context.client.id;
+        }
+        if (context.client.ip || context.client.port) {
+            headers['x-forwarded-for'] = `${context.client.ip ?? ''}:${context.client.port ?? ''}`;
+        }
+        if (context.client.userAgent) {
+            headers['x-forwarded-for-user-agent'] = context.client.userAgent;
+        }
+    }
+    return headers;
+}
+export async function throwOnNotOK(response, message, data) {
+    if (response.ok === false) {
+        throw Object.assign(new Error(message), {
+            response: {
+                status: response.status,
+                body: limitSize(await response.text?.()),
+            },
+            ...data,
+        });
+    }
+    return response;
+}
+function limitSize(text) {
+    if ((text?.length ?? 0) > 2048) {
+        return text?.substring(0, 2048);
+    }
+    return text;
+}
+export async function measure(logger, name, fn, fields) {
+    const start = performance.now();
+    try {
+        return await fn();
+    }
+    finally {
+        const end = performance.now();
+        logger.trace(`Measurement of ${name} time`, undefined, {
+            start: highPrecisionISODate(start),
+            end: highPrecisionISODate(end),
+            duration: (Math.round(end * 10000) - Math.round(start * 10000)) / 10000,
+            ...fields,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["context.ts"],"names":[],"mappings":"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","sourcesContent":["import { performance } from 'perf_hooks'\r\nimport { highPrecisionISODate } from './host/logging.js'\r\n\r\nexport interface Environment {\r\n    readonly [key: string]: string\r\n}\r\n\r\nexport interface Logger {\r\n    enrich(fields: object): Logger\r\n    trace(message: string, error?: unknown, fields?: object): void\r\n    debug(message: string, error?: unknown, fields?: object): void\r\n    info(message: string, error?: unknown, fields?: object): void\r\n    warn(message: string, error?: unknown, fields?: object): void\r\n    error(message: string, error?: unknown, fields?: object): void\r\n    fatal(message: string, error?: unknown, fields?: object): void\r\n}\r\n\r\nexport interface AbortSignal {\r\n    aborted: boolean\r\n\r\n    addEventListener: (\r\n        type: 'abort',\r\n        listener: (this: AbortSignal, event: unknown) => unknown,\r\n        options?: { capture?: boolean; once?: boolean; passive?: boolean },\r\n    ) => void\r\n\r\n    removeEventListener: (\r\n        type: 'abort',\r\n        listener: (this: AbortSignal, event: unknown) => unknown,\r\n        options?: { capture?: boolean },\r\n    ) => void\r\n}\r\n\r\nexport type MutableJson =\r\n    | null\r\n    | boolean\r\n    | number\r\n    | string\r\n    | MutableJson[]\r\n    | { [key: string]: MutableJson }\r\nexport type Json =\r\n    | null\r\n    | boolean\r\n    | number\r\n    | string\r\n    | readonly Json[]\r\n    | { readonly [key: string]: Json }\r\n\r\n/*@__INLINE__*/\r\nexport function objectSpreadable(json?: Json): { readonly [key: string]: Json } {\r\n    if (!json) {\r\n        return {}\r\n    }\r\n    return json as unknown as { readonly [key: string]: Json }\r\n}\r\n\r\n/*@__INLINE__*/\r\nexport function arraySpreadable(json?: Json): readonly Json[] {\r\n    if (!Array.isArray(json)) {\r\n        return []\r\n    }\r\n    return json as readonly Json[]\r\n}\r\n\r\nexport interface HandlerConfiguration {\r\n    /**\r\n     * An indication of CPU usage of the handler.\r\n     * @default 'low'\r\n     */\r\n    readonly compute?: 'high' | 'low'\r\n    /**\r\n     * An indication of memory usage of the handler.\r\n     * @default 'low'\r\n     */\r\n    readonly memory?: 'high' | 'low'\r\n    /**\r\n     * A boolean indicating whether to enrich the log with the body of events, requests or responses. Set to false if the body is large or contain very sensitive data.\r\n     * @default false\r\n     */\r\n    readonly excludeBodyFromLogs?: boolean\r\n    /**\r\n     * The level below which log entries will be discarded.\r\n     * @default 'trace'\r\n     */\r\n    readonly minimumLogLevel?: 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal'\r\n    /**\r\n     * The number of seconds the function is expected to finish executing in.\r\n     */\r\n    readonly timeout?: number\r\n}\r\n\r\nexport interface Context {\r\n    readonly env: Environment\r\n    readonly log: Logger\r\n    readonly signal: AbortSignal\r\n    now(): Date\r\n\r\n    readonly operationId?: string\r\n    readonly client?: {\r\n        readonly id?: string\r\n        readonly ip?: string\r\n        readonly port?: number\r\n        readonly userAgent?: string\r\n    }\r\n    readonly meta?: {\r\n        readonly packageName: string\r\n        readonly fileName: string\r\n        readonly revision?: string\r\n    }\r\n\r\n    emit(topic: string, type: string, subject: string, data?: Json, messageId?: string): void\r\n    eventBarrier(): Promise<void>\r\n\r\n    onSuccess(fn: () => Promise<void> | void): void\r\n}\r\n\r\nexport function httpRequestHeaders(context: Context) {\r\n    const headers: { [key: string]: string } = {\r\n        'user-agent': `${context.meta?.packageName ?? '?'}/${context.meta?.revision ?? '?'}`,\r\n    }\r\n    if (context.operationId) {\r\n        headers['x-request-id'] = context.operationId\r\n    }\r\n    if (context.client) {\r\n        if (context.client.id) {\r\n            headers['x-client-id'] = context.client.id\r\n        }\r\n        if (context.client.ip || context.client.port) {\r\n            headers['x-forwarded-for'] = `${context.client.ip ?? ''}:${context.client.port ?? ''}`\r\n        }\r\n        if (context.client.userAgent) {\r\n            headers['x-forwarded-for-user-agent'] = context.client.userAgent\r\n        }\r\n    }\r\n    return headers\r\n}\r\n\r\nexport async function throwOnNotOK<\r\n    T extends { ok?: boolean; status?: number; text?: () => Promise<string> },\r\n>(response: T, message: string, data?: { [key: string]: unknown }) {\r\n    if (response.ok === false) {\r\n        throw Object.assign(new Error(message), {\r\n            response: {\r\n                status: response.status,\r\n                body: limitSize(await response.text?.()),\r\n            },\r\n            ...data,\r\n        })\r\n    }\r\n    return response\r\n}\r\n\r\nfunction limitSize(text: string | undefined) {\r\n    if ((text?.length ?? 0) > 2048) {\r\n        return text?.substring(0, 2048)\r\n    }\r\n    return text\r\n}\r\n\r\nexport async function measure<T>(\r\n    logger: { trace: (message: string, _: undefined, f: object) => void },\r\n    name: string,\r\n    fn: () => Promise<T> | T,\r\n    fields?: object,\r\n) {\r\n    const start = performance.now()\r\n    try {\r\n        return await fn()\r\n    } finally {\r\n        const end = performance.now()\r\n        logger.trace(`Measurement of ${name} time`, undefined, {\r\n            start: highPrecisionISODate(start),\r\n            end: highPrecisionISODate(end),\r\n            duration: (Math.round(end * 10000) - Math.round(start * 10000)) / 10000,\r\n            ...fields,\r\n        })\r\n    }\r\n}\r\n"]}

package/host/context.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AbortSignal, Context, Environment, Logger } from '../context.js';
+import { Metadata } from './registry.js';
+export interface ClientInfo {
+    readonly operationId?: string;
+    readonly clientId?: string;
+    readonly clientIp?: string;
+    readonly clientPort?: number;
+    readonly userAgent?: string;
+}
+export interface EventMetadata {
+    topic: string;
+    type: string;
+    subject: string;
+    id?: string;
+}
+export interface BufferedEvent {
+    eventTime: Date;
+    meta: Omit<EventMetadata, 'topic'>;
+    ids: ClientInfo;
+    json?: string;
+}
+export interface EventTransport {
+    readonly publishRate: number;
+    sendEvents(topic: string, events: BufferedEvent[], signal: AbortSignal): Promise<void>;
+}
+export declare type LogLevel = 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal';
+export interface LogEntry {
+    readonly level: LogLevel;
+    readonly timestamp: number;
+    readonly message: string;
+    readonly error: unknown;
+    readonly json: string;
+}
+export interface LogTransport {
+    readonly publishRate?: number;
+    sendEntries(entries: LogEntry[], signal: AbortSignal): Promise<void> | undefined;
+}
+export interface RootLogger extends Logger {
+    enrichReserved(fields: object): RootLogger;
+    flush(): Promise<void>;
+}
+export declare function createContext(clientInfo: ClientInfo, loggers: LogTransport[], eventTransport: EventTransport, timeouts: {
+    default: number;
+    cap?: number;
+}, outerController: AbortController, meta?: Metadata, environment?: Environment | undefined, now?: (() => Date) | undefined): {
+    log: RootLogger;
+    context: Context;
+    success: () => Promise<unknown>;
+    flush: () => Promise<void>;
+};

package/host/context.js

@@ -0,0 +1,104 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LogMulticaster_transports;
+import { EventEmitter } from './emitter.js';
+import { makeLogger } from './logging.js';
+class LogMulticaster {
+    constructor(transports) {
+        _LogMulticaster_transports.set(this, void 0);
+        __classPrivateFieldSet(this, _LogMulticaster_transports, transports, "f");
+        this.publishRate = transports.map(t => t.publishRate).sort()[0] ?? Number.MAX_SAFE_INTEGER;
+    }
+    sendEntries(entries, signal) {
+        const promises = __classPrivateFieldGet(this, _LogMulticaster_transports, "f").map(t => t.sendEntries(entries, signal)).filter(p => !!p);
+        if (promises.length === 0) {
+            return;
+        }
+        return Promise.all(promises);
+    }
+}
+_LogMulticaster_transports = new WeakMap();
+export function createContext(clientInfo, loggers, eventTransport, timeouts, outerController, meta, environment, now) {
+    const timeout = (timeouts.cap
+        ? Math.min(meta?.config?.timeout ?? timeouts.default, timeouts.cap)
+        : meta?.config?.timeout ?? timeouts.default) * 1000;
+    const innerController = new AbortController();
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const logTransport = loggers.length === 1 ? loggers[0] : new LogMulticaster(loggers);
+    const logger = makeLogger(logTransport, meta?.config?.minimumLogLevel, outerController.signal);
+    logger.enrichReserved({
+        operationId: clientInfo.operationId,
+        client: {
+            id: clientInfo.clientId,
+            ip: clientInfo.clientIp,
+            port: clientInfo.clientPort,
+            userAgent: clientInfo.userAgent,
+        },
+    });
+    globalLogger = logger;
+    const emitter = new EventEmitter(eventTransport, logger, clientInfo, timeout, outerController.signal);
+    const successHandlers = [];
+    const ctx = {
+        env: environment ?? process.env,
+        log: logger,
+        signal: innerController.signal,
+        now: now ?? (() => new Date()),
+        operationId: clientInfo.operationId,
+        client: {
+            id: clientInfo.clientId,
+            ip: clientInfo.clientIp,
+            port: clientInfo.clientPort,
+            userAgent: clientInfo.userAgent,
+        },
+        meta: meta
+            ? {
+                packageName: meta.packageName,
+                fileName: meta.fileName,
+                revision: meta.revision,
+            }
+            : undefined,
+        emit: (topic, type, subject, data, messageId) => emitter.emit({ topic, type, subject, id: messageId }, data),
+        eventBarrier: () => emitter.flush(),
+        onSuccess: (fn) => successHandlers.push(fn),
+    };
+    const timeoutHandle = setTimeout(() => {
+        ctx.log.error('Timeout.', undefined, undefined);
+        innerController.abort();
+        // eslint-disable-next-line no-void
+        void logger.flush();
+        // eslint-disable-next-line no-void
+        void emitter.flush();
+    }, timeout);
+    const flushHandle = setTimeout(() => {
+        ctx.log.error('Aborting flush.', undefined, undefined);
+        outerController.abort();
+    }, timeout + 15000);
+    return {
+        log: logger,
+        context: ctx,
+        success: () => Promise.all(successHandlers.map(fn => fn())),
+        flush: async () => {
+            clearTimeout(timeoutHandle);
+            await emitter.flush();
+            await logger.flush();
+            clearTimeout(flushHandle);
+        },
+    };
+}
+let globalLogger;
+process.on('uncaughtException', err => {
+    globalLogger?.fatal('Uncaught exception.', err, undefined);
+});
+process.on('unhandledRejection', reason => {
+    globalLogger?.fatal('Unhandled rejection.', reason, undefined);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["context.ts"],"names":[],"mappings":";;;;;;;;;;;;AACA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AA6CzC,MAAM,cAAc;IAIhB,YAAY,UAA0B;QAHtC,6CAA2B;QAIvB,uBAAA,IAAI,8BAAe,UAAU,MAAA,CAAA;QAC7B,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,gBAAgB,CAAA;IAC9F,CAAC;IAED,WAAW,CAAC,OAAmB,EAAE,MAAmB;QAChD,MAAM,QAAQ,GAAG,uBAAA,IAAI,kCAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QAC3F,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;YACvB,OAAM;SACT;QACD,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,CAA6B,CAAA;IAC5D,CAAC;CACJ;;AAOD,MAAM,UAAU,aAAa,CACzB,UAAsB,EACtB,OAAuB,EACvB,cAA8B,EAC9B,QAA2C,EAC3C,eAAgC,EAChC,IAAe,EACf,WAAqC,EACrC,GAA8B;IAO9B,MAAM,OAAO,GACT,CAAC,QAAQ,CAAC,GAAG;QACT,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,IAAI,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC;QACnE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IAC3D,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAA;IAC7C,oEAAoE;IACpE,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,OAAO,CAAC,CAAA;IACrF,MAAM,MAAM,GAAG,UAAU,CACrB,YAAY,EACZ,IAAI,EAAE,MAAM,EAAE,eAAe,EAC7B,eAAe,CAAC,MAAqB,CACxC,CAAA;IACD,MAAM,CAAC,cAAc,CAAC;QAClB,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,MAAM,EAAE;YACJ,EAAE,EAAE,UAAU,CAAC,QAAQ;YACvB,EAAE,EAAE,UAAU,CAAC,QAAQ;YACvB,IAAI,EAAE,UAAU,CAAC,UAAU;YAC3B,SAAS,EAAE,UAAU,CAAC,SAAS;SAClC;KACJ,CAAC,CAAA;IACF,YAAY,GAAG,MAAM,CAAA;IACrB,MAAM,OAAO,GAAG,IAAI,YAAY,CAC5B,cAAc,EACd,MAAM,EACN,UAAU,EACV,OAAO,EACP,eAAe,CAAC,MAAqB,CACxC,CAAA;IACD,MAAM,eAAe,GAAmC,EAAE,CAAA;IAC1D,MAAM,GAAG,GAAG;QACR,GAAG,EAAE,WAAW,IAAK,OAAO,CAAC,GAAmB;QAChD,GAAG,EAAE,MAAM;QACX,MAAM,EAAE,eAAe,CAAC,MAAqB;QAC7C,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC;QAC9B,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,MAAM,EAAE;YACJ,EAAE,EAAE,UAAU,CAAC,QAAQ;YACvB,EAAE,EAAE,UAAU,CAAC,QAAQ;YACvB,IAAI,EAAE,UAAU,CAAC,UAAU;YAC3B,SAAS,EAAE,UAAU,CAAC,SAAS;SAClC;QACD,IAAI,EAAE,IAAI;YACN,CAAC,CAAC;gBACI,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;aAC1B;YACH,CAAC,CAAC,SAAS;QACf,IAAI,EAAE,CAAC,KAAa,EAAE,IAAY,EAAE,OAAe,EAAE,IAAW,EAAE,SAAkB,EAAE,EAAE,CACpF,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,IAAI,CAAC;QAC/D,YAAY,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE;QACnC,SAAS,EAAE,CAAC,EAA8B,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;KAC1E,CAAA;IACD,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;QAClC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;QAC/C,eAAe,CAAC,KAAK,EAAE,CAAA;QACvB,mCAAmC;QACnC,KAAK,MAAM,CAAC,KAAK,EAAE,CAAA;QACnB,mCAAmC;QACnC,KAAK,OAAO,CAAC,KAAK,EAAE,CAAA;IACxB,CAAC,EAAE,OAAO,CAAC,CAAA;IACX,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;QAChC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,iBAAiB,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;QACtD,eAAe,CAAC,KAAK,EAAE,CAAA;IAC3B,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC,CAAA;IACnB,OAAO;QACH,GAAG,EAAE,MAAM;QACX,OAAO,EAAE,GAAG;QACZ,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC3D,KAAK,EAAE,KAAK,IAAI,EAAE;YACd,YAAY,CAAC,aAAa,CAAC,CAAA;YAC3B,MAAM,OAAO,CAAC,KAAK,EAAE,CAAA;YACrB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAA;YACpB,YAAY,CAAC,WAAW,CAAC,CAAA;QAC7B,CAAC;KACJ,CAAA;AACL,CAAC;AAED,IAAI,YAAgC,CAAA;AAEpC,OAAO,CAAC,EAAE,CAAC,mBAAmB,EAAE,GAAG,CAAC,EAAE;IAClC,YAAY,EAAE,KAAK,CAAC,qBAAqB,EAAE,GAAG,EAAE,SAAS,CAAC,CAAA;AAC9D,CAAC,CAAC,CAAA;AACF,OAAO,CAAC,EAAE,CAAC,oBAAoB,EAAE,MAAM,CAAC,EAAE;IACtC,YAAY,EAAE,KAAK,CAAC,sBAAsB,EAAE,MAAM,EAAE,SAAS,CAAC,CAAA;AAClE,CAAC,CAAC,CAAA","sourcesContent":["import { AbortSignal, Context, Environment, Json, Logger } from '../context.js'\r\nimport { EventEmitter } from './emitter.js'\r\nimport { makeLogger } from './logging.js'\r\nimport { Metadata } from './registry.js'\r\n\r\nexport interface ClientInfo {\r\n    readonly operationId?: string\r\n    readonly clientId?: string\r\n    readonly clientIp?: string\r\n    readonly clientPort?: number\r\n    readonly userAgent?: string\r\n}\r\n\r\nexport interface EventMetadata {\r\n    topic: string\r\n    type: string\r\n    subject: string\r\n    id?: string\r\n}\r\n\r\nexport interface BufferedEvent {\r\n    eventTime: Date\r\n    meta: Omit<EventMetadata, 'topic'>\r\n    ids: ClientInfo\r\n    json?: string\r\n}\r\n\r\nexport interface EventTransport {\r\n    readonly publishRate: number\r\n    sendEvents(topic: string, events: BufferedEvent[], signal: AbortSignal): Promise<void>\r\n}\r\n\r\nexport type LogLevel = 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal'\r\n\r\nexport interface LogEntry {\r\n    readonly level: LogLevel\r\n    readonly timestamp: number\r\n    readonly message: string\r\n    readonly error: unknown\r\n    readonly json: string\r\n}\r\n\r\nexport interface LogTransport {\r\n    readonly publishRate?: number\r\n    sendEntries(entries: LogEntry[], signal: AbortSignal): Promise<void> | undefined\r\n}\r\n\r\nclass LogMulticaster implements LogTransport {\r\n    #transports: LogTransport[]\r\n    readonly publishRate: number\r\n\r\n    constructor(transports: LogTransport[]) {\r\n        this.#transports = transports\r\n        this.publishRate = transports.map(t => t.publishRate).sort()[0] ?? Number.MAX_SAFE_INTEGER\r\n    }\r\n\r\n    sendEntries(entries: LogEntry[], signal: AbortSignal) {\r\n        const promises = this.#transports.map(t => t.sendEntries(entries, signal)).filter(p => !!p)\r\n        if (promises.length === 0) {\r\n            return\r\n        }\r\n        return Promise.all(promises) as unknown as Promise<void>\r\n    }\r\n}\r\n\r\nexport interface RootLogger extends Logger {\r\n    enrichReserved(fields: object): RootLogger\r\n    flush(): Promise<void>\r\n}\r\n\r\nexport function createContext(\r\n    clientInfo: ClientInfo,\r\n    loggers: LogTransport[],\r\n    eventTransport: EventTransport,\r\n    timeouts: { default: number; cap?: number },\r\n    outerController: AbortController,\r\n    meta?: Metadata,\r\n    environment?: Environment | undefined,\r\n    now?: (() => Date) | undefined,\r\n): {\r\n    log: RootLogger\r\n    context: Context\r\n    success: () => Promise<unknown>\r\n    flush: () => Promise<void>\r\n} {\r\n    const timeout =\r\n        (timeouts.cap\r\n            ? Math.min(meta?.config?.timeout ?? timeouts.default, timeouts.cap)\r\n            : meta?.config?.timeout ?? timeouts.default) * 1000\r\n    const innerController = new AbortController()\r\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\r\n    const logTransport = loggers.length === 1 ? loggers[0]! : new LogMulticaster(loggers)\r\n    const logger = makeLogger(\r\n        logTransport,\r\n        meta?.config?.minimumLogLevel,\r\n        outerController.signal as AbortSignal,\r\n    )\r\n    logger.enrichReserved({\r\n        operationId: clientInfo.operationId,\r\n        client: {\r\n            id: clientInfo.clientId,\r\n            ip: clientInfo.clientIp,\r\n            port: clientInfo.clientPort,\r\n            userAgent: clientInfo.userAgent,\r\n        },\r\n    })\r\n    globalLogger = logger\r\n    const emitter = new EventEmitter(\r\n        eventTransport,\r\n        logger,\r\n        clientInfo,\r\n        timeout,\r\n        outerController.signal as AbortSignal,\r\n    )\r\n    const successHandlers: (() => Promise<void> | void)[] = []\r\n    const ctx = {\r\n        env: environment ?? (process.env as Environment),\r\n        log: logger,\r\n        signal: innerController.signal as AbortSignal,\r\n        now: now ?? (() => new Date()),\r\n        operationId: clientInfo.operationId,\r\n        client: {\r\n            id: clientInfo.clientId,\r\n            ip: clientInfo.clientIp,\r\n            port: clientInfo.clientPort,\r\n            userAgent: clientInfo.userAgent,\r\n        },\r\n        meta: meta\r\n            ? {\r\n                  packageName: meta.packageName,\r\n                  fileName: meta.fileName,\r\n                  revision: meta.revision,\r\n              }\r\n            : undefined,\r\n        emit: (topic: string, type: string, subject: string, data?: Json, messageId?: string) =>\r\n            emitter.emit({ topic, type, subject, id: messageId }, data),\r\n        eventBarrier: () => emitter.flush(),\r\n        onSuccess: (fn: () => Promise<void> | void) => successHandlers.push(fn),\r\n    }\r\n    const timeoutHandle = setTimeout(() => {\r\n        ctx.log.error('Timeout.', undefined, undefined)\r\n        innerController.abort()\r\n        // eslint-disable-next-line no-void\r\n        void logger.flush()\r\n        // eslint-disable-next-line no-void\r\n        void emitter.flush()\r\n    }, timeout)\r\n    const flushHandle = setTimeout(() => {\r\n        ctx.log.error('Aborting flush.', undefined, undefined)\r\n        outerController.abort()\r\n    }, timeout + 15000)\r\n    return {\r\n        log: logger,\r\n        context: ctx,\r\n        success: () => Promise.all(successHandlers.map(fn => fn())),\r\n        flush: async () => {\r\n            clearTimeout(timeoutHandle)\r\n            await emitter.flush()\r\n            await logger.flush()\r\n            clearTimeout(flushHandle)\r\n        },\r\n    }\r\n}\r\n\r\nlet globalLogger: Logger | undefined\r\n\r\nprocess.on('uncaughtException', err => {\r\n    globalLogger?.fatal('Uncaught exception.', err, undefined)\r\n})\r\nprocess.on('unhandledRejection', reason => {\r\n    globalLogger?.fatal('Unhandled rejection.', reason, undefined)\r\n})\r\n"]}

package/host/emitter.d.ts

@@ -0,0 +1,13 @@
+import { AbortSignal, Json, Logger } from '../context.js';
+import { EventMetadata, EventTransport } from './context.js';
+export declare class EventEmitter {
+    #private;
+    constructor(transport: EventTransport, logger: Logger, ids: {
+        operationId?: string;
+        clientId?: string;
+        clientIp?: string;
+        userAgent?: string;
+    }, timeout: number, signal: AbortSignal);
+    emit(meta: EventMetadata, data?: Json): void;
+    flush(): Promise<void>;
+}

package/host/emitter.js

@@ -0,0 +1,81 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EventEmitter_instances, _EventEmitter_transport, _EventEmitter_logger, _EventEmitter_ids, _EventEmitter_emitted, _EventEmitter_size, _EventEmitter_flusher, _EventEmitter_deadline, _EventEmitter_buffered, _EventEmitter_signal, _EventEmitter_startFlush, _EventEmitter_flushEvents;
+export class EventEmitter {
+    constructor(transport, logger, ids, timeout, signal) {
+        _EventEmitter_instances.add(this);
+        _EventEmitter_transport.set(this, void 0);
+        _EventEmitter_logger.set(this, void 0);
+        _EventEmitter_ids.set(this, void 0);
+        _EventEmitter_emitted.set(this, {});
+        _EventEmitter_size.set(this, 0);
+        _EventEmitter_flusher.set(this, void 0);
+        _EventEmitter_deadline.set(this, void 0);
+        _EventEmitter_buffered.set(this, void 0);
+        _EventEmitter_signal.set(this, void 0);
+        __classPrivateFieldSet(this, _EventEmitter_transport, transport, "f");
+        __classPrivateFieldSet(this, _EventEmitter_logger, logger, "f");
+        __classPrivateFieldSet(this, _EventEmitter_ids, ids, "f");
+        __classPrivateFieldSet(this, _EventEmitter_deadline, new Date().getTime() + timeout, "f");
+        __classPrivateFieldSet(this, _EventEmitter_buffered, 0, "f");
+        __classPrivateFieldSet(this, _EventEmitter_signal, signal, "f");
+    }
+    emit(meta, data) {
+        var _a;
+        const eventTime = new Date();
+        const timeLeft = __classPrivateFieldGet(this, _EventEmitter_deadline, "f") - new Date().getTime();
+        if (__classPrivateFieldGet(this, _EventEmitter_buffered, "f") / __classPrivateFieldGet(this, _EventEmitter_transport, "f").publishRate > timeLeft) {
+            throw new Error('Event overflow.');
+        }
+        const event = data === undefined
+            ? { meta, ids: __classPrivateFieldGet(this, _EventEmitter_ids, "f"), eventTime }
+            : { meta, ids: __classPrivateFieldGet(this, _EventEmitter_ids, "f"), eventTime, json: JSON.stringify(data) };
+        const events = __classPrivateFieldGet(this, _EventEmitter_emitted, "f")[meta.topic];
+        if (!events) {
+            __classPrivateFieldGet(this, _EventEmitter_emitted, "f")[meta.topic] = [event];
+        }
+        else {
+            events.push(event);
+            if (events.length > 64 || __classPrivateFieldGet(this, _EventEmitter_size, "f") > 64000) {
+                // eslint-disable-next-line no-void
+                void this.flush();
+            }
+        }
+        __classPrivateFieldSet(this, _EventEmitter_buffered, (_a = __classPrivateFieldGet(this, _EventEmitter_buffered, "f"), ++_a), "f");
+        __classPrivateFieldSet(this, _EventEmitter_size, __classPrivateFieldGet(this, _EventEmitter_size, "f") + (event.json?.length ?? 0), "f");
+    }
+    async flush() {
+        __classPrivateFieldGet(this, _EventEmitter_instances, "m", _EventEmitter_startFlush).call(this, __classPrivateFieldGet(this, _EventEmitter_emitted, "f"));
+        __classPrivateFieldSet(this, _EventEmitter_emitted, {}, "f");
+        __classPrivateFieldSet(this, _EventEmitter_size, 0, "f");
+        return await __classPrivateFieldGet(this, _EventEmitter_flusher, "f");
+    }
+}
+_EventEmitter_transport = new WeakMap(), _EventEmitter_logger = new WeakMap(), _EventEmitter_ids = new WeakMap(), _EventEmitter_emitted = new WeakMap(), _EventEmitter_size = new WeakMap(), _EventEmitter_flusher = new WeakMap(), _EventEmitter_deadline = new WeakMap(), _EventEmitter_buffered = new WeakMap(), _EventEmitter_signal = new WeakMap(), _EventEmitter_instances = new WeakSet(), _EventEmitter_startFlush = function _EventEmitter_startFlush(emitted) {
+    if (__classPrivateFieldGet(this, _EventEmitter_flusher, "f")) {
+        __classPrivateFieldSet(this, _EventEmitter_flusher, __classPrivateFieldGet(this, _EventEmitter_flusher, "f").then(() => __classPrivateFieldGet(this, _EventEmitter_instances, "m", _EventEmitter_flushEvents).call(this, emitted)), "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _EventEmitter_flusher, __classPrivateFieldGet(this, _EventEmitter_instances, "m", _EventEmitter_flushEvents).call(this, emitted), "f");
+    }
+}, _EventEmitter_flushEvents = async function _EventEmitter_flushEvents(emitted) {
+    await Promise.all(Object.entries(emitted).map(async ([topic, events]) => {
+        try {
+            await __classPrivateFieldGet(this, _EventEmitter_transport, "f").sendEvents(topic, events, __classPrivateFieldGet(this, _EventEmitter_signal, "f"));
+        }
+        catch (e) {
+            __classPrivateFieldGet(this, _EventEmitter_logger, "f").fatal('Error sending events.', e, { events });
+        }
+        __classPrivateFieldSet(this, _EventEmitter_buffered, __classPrivateFieldGet(this, _EventEmitter_buffered, "f") - events.length, "f");
+    }));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/host/http.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Context } from '../context.js';
+import type { Json } from '../http.js';
+import { ClientInfo, RootLogger } from './context.js';
+import type { HttpHandler } from './registry.js';
+export interface Response {
+    headers: {
+        readonly [key: string]: string;
+    };
+    status: number;
+    body?: string | Buffer;
+}
+declare type RequestOptions = BodylessRequestOptions | StringRequestOptions | JsonRequestOptions;
+interface BodylessRequestOptions {
+    uri: string;
+    headers?: {
+        readonly [key: string]: string;
+    };
+}
+interface StringRequestOptions extends BodylessRequestOptions {
+    body: string;
+}
+interface JsonRequestOptions extends BodylessRequestOptions {
+    json: Json;
+}
+export declare function executeRequest(log: RootLogger, context: Context, handler: HttpHandler, options: RequestOptions, success: () => Promise<unknown>): Promise<Response>;
+export declare function clientFromHeaders(headers: {
+    readonly [key: string]: string;
+} | undefined): ClientInfo;
+export {};