@amkisko/json-logging 0.0.0-stage → 0.1.1

package/dist/sinks.js

@@ -0,0 +1,66 @@
+import { captureConsoleMethods, getBridgeOriginals } from "./console-state.js";
+function pickMethod(methods, severity) {
+    const name = typeof severity === "string" ? severity.toUpperCase() : "INFO";
+    switch (name) {
+        case "ERROR":
+        case "FATAL":
+            return methods.error;
+        case "WARN":
+            return methods.warn;
+        case "DEBUG":
+            return methods.debug;
+        default:
+            return methods.info;
+    }
+}
+/** Writes JSON lines using the given console method table (usually pre-bridge originals). */
+export function consoleSinkFrom(methods) {
+    return {
+        write(line, record) {
+            const method = pickMethod(methods, record.severity);
+            const trimmed = line.endsWith("\n") ? line.slice(0, -1) : line;
+            method(trimmed);
+        },
+    };
+}
+/**
+ * Default console sink. When a console bridge is installed, writes through the
+ * captured originals so logger calls do not re-enter the bridge.
+ */
+export function consoleSink() {
+    return {
+        write(line, record) {
+            const methods = getBridgeOriginals() ?? captureConsoleMethods(console);
+            const method = pickMethod(methods, record.severity);
+            const trimmed = line.endsWith("\n") ? line.slice(0, -1) : line;
+            method(trimmed);
+        },
+    };
+}
+/** Sink that writes JSON lines to a Web Streams `WritableStream`. */
+export function streamSink(stream, options) {
+    const encoding = options?.encoding ?? "utf-8";
+    const encoder = new TextEncoder();
+    let chain = Promise.resolve();
+    return {
+        write(line, _record) {
+            const chunk = line.endsWith("\n") ? line : `${line}\n`;
+            const bytes = encoding === "utf-8" ? encoder.encode(chunk) : encoder.encode(chunk);
+            chain = chain
+                .then(async () => {
+                const writer = stream.getWriter();
+                try {
+                    await writer.write(bytes);
+                }
+                finally {
+                    writer.releaseLock();
+                }
+            })
+                .catch(() => {
+                // Never throw from the sink chain; swallow write failures.
+            });
+            return chain;
+        },
+    };
+}
+//# sourceMappingURL=sinks.js.map

package/dist/timestamp.d.ts

@@ -0,0 +1,15 @@
+/** Format a Date as an ISO-8601 UTC string ending in `Z`. */
+export declare function formatTimestamp(date: Date): string;
+/** Subset of the Performance API used for microsecond timestamps. */
+export type PerformanceLike = {
+    now: () => number;
+    timeOrigin: number;
+};
+/**
+ * Prefer microsecond precision via performance.timeOrigin when no test clock is set.
+ * Pass perf=null to force the Date millisecond fallback.
+ */
+export declare function currentTimestamp(clock?: () => Date, perf?: PerformanceLike | null): string;
+/** Resolve `globalThis.performance` when it looks like {@link PerformanceLike}. */
+export declare function defaultPerformance(globalPerf?: unknown | null): PerformanceLike | undefined;
+//# sourceMappingURL=timestamp.d.ts.map

package/dist/timestamp.js

@@ -0,0 +1,47 @@
+/** Format a Date as an ISO-8601 UTC string ending in `Z`. */
+export function formatTimestamp(date) {
+    return date.toISOString();
+}
+function isPerformanceLike(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    return (typeof Reflect.get(value, "now") === "function" &&
+        typeof Reflect.get(value, "timeOrigin") === "number");
+}
+/**
+ * Prefer microsecond precision via performance.timeOrigin when no test clock is set.
+ * Pass perf=null to force the Date millisecond fallback.
+ */
+export function currentTimestamp(clock, perf) {
+    if (clock) {
+        return formatTimestamp(clock());
+    }
+    const resolved = perf === undefined ? defaultPerformance() : (perf ?? undefined);
+    try {
+        if (resolved) {
+            const epochMs = resolved.timeOrigin + resolved.now();
+            const wholeSeconds = Math.floor(epochMs / 1000);
+            const micros = Math.round((epochMs % 1000) * 1000);
+            const isoSecond = new Date(wholeSeconds * 1000).toISOString().replace(/\.\d{3}Z$/, "");
+            return `${isoSecond}.${String(micros).padStart(6, "0")}Z`;
+        }
+    }
+    catch {
+        // fall through to Date
+    }
+    return formatTimestamp(new Date());
+}
+/** Resolve `globalThis.performance` when it looks like {@link PerformanceLike}. */
+export function defaultPerformance(globalPerf) {
+    const resolved = globalPerf === undefined
+        ? typeof performance !== "undefined"
+            ? performance
+            : undefined
+        : globalPerf;
+    if (isPerformanceLike(resolved)) {
+        return resolved;
+    }
+    return undefined;
+}
+//# sourceMappingURL=timestamp.js.map

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+/** Minimum severity that will be emitted. */
+export type Level = "debug" | "info" | "warn" | "error" | "fatal";
+/** Uppercase severity string written on each log line. */
+export type SeverityName = "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL";
+/** Value accepted by severity methods: plain text, structured fields, or an Error. */
+export type LogMessage = string | Record<string, unknown> | Error;
+/** Sanitized object passed to sinks and JSON serialization. */
+export type LogRecord = Record<string, unknown>;
+/** Destination for one JSON line plus its record. */
+export type Sink = {
+    write(line: string, record: LogRecord): void | Promise<void>;
+};
+/** Root-field transform applied after message parse and before path redact. */
+export type FieldSerializer = (value: unknown) => unknown;
+/** Optional ambient enrichment at log time (e.g. trace ids). Must not throw; throws take never-raise fallback. */
+export type ContextProvider = () => Record<string, unknown> | undefined;
+/** Construction options for {@link Logger}. */
+export type LoggerOptions = {
+    /** Minimum level to emit. Default `info`. */
+    level?: Level;
+    /** Output destination. Default console sink. */
+    sink?: Sink;
+    /** Fields merged into every line at the root. */
+    base?: Record<string, unknown>;
+    /** Clock for timestamps (tests). */
+    clock?: () => Date;
+    /** Sticky tags applied to every line from this logger. */
+    tags?: readonly string[];
+    /** Dot paths to filter (config-time only). Segment `*` matches one key or index. */
+    redact?: readonly string[];
+    /** Root field name to serializer. */
+    serializers?: Readonly<Record<string, FieldSerializer>>;
+    /** Merged under `context` after ALS ambient context; call-site context wins. */
+    contextProvider?: ContextProvider;
+};
+/** JSON scalar used in sanitized payloads. */
+export type JsonPrimitive = string | number | boolean | null;
+/** JSON-compatible value after sanitization. */
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,100 @@
 {
   "name": "@amkisko/json-logging",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Structured JSON logging with ActiveSupport-style tagged and withContext helpers",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amkisko/json-logging.ts.git"
+  },
+  "homepage": "https://github.com/amkisko/json-logging.ts#readme",
+  "bugs": {
+    "url": "https://github.com/amkisko/json-logging.ts/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./console": {
+      "types": "./dist/console.d.ts",
+      "import": "./dist/console.js"
+    },
+    "./http": {
+      "types": "./dist/http.d.ts",
+      "import": "./dist/http.js"
+    },
+    "./next": {
+      "types": "./dist/next.d.ts",
+      "import": "./dist/next.js"
+    },
+    "./remix": {
+      "types": "./dist/remix.d.ts",
+      "import": "./dist/remix.js"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.js"
+    },
+    "./express": {
+      "types": "./dist/express.d.ts",
+      "import": "./dist/express.js"
+    },
+    "./fastify": {
+      "types": "./dist/fastify.d.ts",
+      "import": "./dist/fastify.js"
+    },
+    "./koa": {
+      "types": "./dist/koa.d.ts",
+      "import": "./dist/koa.js"
+    },
+    "./bun": {
+      "types": "./dist/bun-serve.d.ts",
+      "import": "./dist/bun-serve.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "type-coverage": "type-coverage --project tsconfig.json --at-least 100 --strict",
+    "lint": "make lint",
+    "lint:biome": "make lint-biome",
+    "format": "npx --yes @biomejs/biome@2.3.8 check --write .",
+    "check": "make check",
+    "ci": "make ci",
+    "publish:npm": "npm publish --access public",
+    "publish:jsr": "npx --yes jsr publish"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^12.3.2",
+    "@nestjs/core": "^12.3.2",
+    "@nestjs/platform-express": "^12.3.2",
+    "@nestjs/platform-fastify": "^12.3.2",
+    "@remix-run/node": "2",
+    "@types/bun": "^1.4.4",
+    "@types/express": "^5.0.6",
+    "@types/koa": "^3.0.3",
+    "express": "^5.3.0",
+    "fastify": "^5.12.7",
+    "hono": "^4.13.14",
+    "koa": "^3.2.1",
+    "next": "15",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
+    "type-coverage": "^2.29.7",
+    "typescript": "^5.9.3"
+  }
+}