@logscopeai/logscope 0.1.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Logscope
+
+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/README.md

@@ -0,0 +1,341 @@
+# logscope
+
+> ⚠️ **Pre-release Software**
+>
+> This package is experimental and must not be used in production environments.
+> It is provided strictly for local testing, development, and proof-of-concept validation.
+> Breaking changes may occur in any minor or patch release.
+
+`logscope` is the official Node.js SDK for Logscope.
+
+It enables Node.js applications to capture logs, normalize them, enrich them with execution context, and send them asynchronously to the Logscope Ingestion API for downstream processing.
+
+Logscope is currently in early development. This SDK is intended for proof-of-concept validation and is not production-ready.
+
+---
+
+## Early Development Mode
+
+During early development phases, `logscope` is expected to be executed locally using:
+
+```
+npm link
+```
+
+This allows the SDK to be developed and tested inside a consuming service before being published to npm.
+
+The intended import pattern is:
+
+```ts
+import { Logscope } from 'logscope';
+```
+
+Compatibility with `npm link` is a design requirement.
+
+---
+
+## What This Package Does
+
+- Captures logs from:
+  - `console.log`, `console.info`, `console.warn`, `console.error` (opt-in)
+  - Manual SDK logging API
+  - Pino (via explicit transport)
+
+- Normalizes logs to the Logscope ingestion contract
+- Applies optional client-side filtering
+- Batches logs (max 50 per request)
+- Sends logs asynchronously to the Logscope Ingestion API
+- Never throws into user code
+
+---
+
+## What This Package Does Not Do
+
+- Store logs
+- Query logs
+- Render dashboards
+- Perform AI analysis
+- Persist logs to disk
+- Replace structured logging frameworks
+
+---
+
+## Installation
+
+```
+npm install logscope
+```
+
+Or during development:
+
+```
+npm link logscope
+```
+
+---
+
+## Basic Usage (Class API)
+
+```ts
+import { Logscope } from 'logscope';
+
+const logscope = new Logscope({
+  apiKey: process.env.LOGSCOPE_API_KEY!,
+});
+
+logscope.info('Service started');
+logscope.error('Payment failed', { orderId: 123 });
+```
+
+`new Logscope({ apiKey })` uses the production ingestion URL default:
+
+```text
+https://ingestion.logscopeai.com
+```
+
+For development/testing, override `ingestionBaseUrl` explicitly:
+
+```ts
+const logscope = new Logscope({
+  apiKey: process.env.LOGSCOPE_API_KEY!,
+  ingestionBaseUrl: 'http://localhost:3000',
+});
+```
+
+Compatibility API (`createLogscopeClient`) remains available:
+
+```ts
+import { createLogscopeClient } from 'logscope';
+
+const logscope = createLogscopeClient({
+  apiKey: process.env.LOGSCOPE_API_KEY!,
+  captureConsole: true,
+  context: {
+    source: 'billing-api',
+  },
+  logFilter: {
+    levels: ['warn', 'error'],
+  },
+  runtime: {
+    maxBatchSize: 25,
+    flushIntervalMs: 1_000,
+    maxRetries: 5,
+    retryBaseDelayMs: 200,
+    retryMaxDelayMs: 4_000,
+  },
+});
+```
+
+Manual API calls (`trace`/`debug`/`info`/`warn`/`error`/`fatal`) normalize logs and enqueue them for asynchronous batching (max 50 entries per request, interval flush fallback).
+
+---
+
+## Validation and Safety Guards
+
+Runtime guards are applied before delivery:
+
+- Required config fields are validated:
+  - Client: `apiKey`
+  - Pino transport: `apiKey`, `endpoint`, `source`
+- Invalid required config triggers a single safe warning and switches to a no-op fallback pipeline.
+- Warning diagnostics never include secret values such as API keys.
+- `ingestionBaseUrl` is optional in SDK client config. Missing or invalid values fallback to the production default.
+- `context.source` is optional; when omitted, emitted logs use deterministic fallback source value `unknown`.
+- The SDK does not expose an `environment` routing field. Tenant/environment ownership is resolved by API key scope on the ingestion side.
+
+Normalization enforces ingestion constraints:
+
+- `message` is deterministically truncated to `<= 2048` characters.
+- `metadata` is normalized to JSON-safe content and dropped if serialized size is `> 2048` bytes.
+
+All guard paths are fail-safe and never throw into user code.
+
+---
+
+## Public Types and Utilities
+
+The root entrypoint also exports shared contracts and normalization utilities:
+
+```ts
+import { Logscope, normalizeLog } from 'logscope';
+import type {
+  IngestionLogEntry,
+  LogLevel,
+  LogscopeClient,
+  LogscopeConfig,
+  LogscopeInitConfig,
+} from 'logscope';
+```
+
+`normalizeLog` converts SDK log input into ingestion-safe entries using `{ source, level, timestamp, message, metadata? }`.
+
+---
+
+## Filtering Logs
+
+Users may restrict which logs are sent to Logscope:
+
+```ts
+logFilter: {
+  levels: ['warn', 'error'],
+}
+```
+
+If no filter is configured, all logs are sent.
+
+If `logFilter.levels` is configured as an empty array (`[]`), all logs are filtered out.
+
+---
+
+## Runtime Delivery Configuration
+
+Runtime batching and retry quantities are configurable through `runtime` on client config:
+
+```ts
+runtime: {
+  maxBatchSize?: number; // default: 50 (bounded to ingestion contract max)
+  flushIntervalMs?: number; // default: 2000
+  maxRetries?: number; // default: 3
+  retryBaseDelayMs?: number; // default: 250
+  retryMaxDelayMs?: number; // default: 2000
+}
+```
+
+Invalid runtime quantity overrides are ignored safely and fallback to defaults without throwing.
+
+---
+
+## Console Capture
+
+`captureConsole` is disabled by default.
+
+When set to `true`, the SDK wraps:
+
+- `console.log` (mapped to `info`)
+- `console.info` (mapped to `info`)
+- `console.warn` (mapped to `warn`)
+- `console.error` (mapped to `error`)
+
+Wrapped methods keep original console output and arguments, and captured entries are forwarded through the same filtering and batching pipeline used by the manual client API.
+
+---
+
+## Using Logscope with Pino
+
+Logscope does not intercept pino automatically.
+
+Instead, it provides an explicit transport:
+
+```ts
+import pino from 'pino';
+
+const logger = pino({
+  transport: {
+    targets: [
+      {
+        target: 'logscope/pino',
+        options: {
+          apiKey: process.env.LOGSCOPE_API_KEY,
+          endpoint: 'http://localhost:3000',
+          source: 'billing-api',
+        },
+      },
+    ],
+  },
+});
+```
+
+The transport maps standard pino levels (`10/20/30/40/50/60`) to Logscope levels (`trace/debug/info/warn/error/fatal`), applies `logFilter.levels` before enqueueing, and sends through the same batch/retry pipeline.
+
+---
+
+## API Contract
+
+Logs are sent to:
+
+```
+POST /api/logs/ingest
+```
+
+Using header:
+
+```
+x-api-key: <LOGSCOPE_API_KEY>
+```
+
+The request body must follow the ingestion API contract defined in the Logscope specification.
+
+Transport status handling is classified as:
+
+- `202` -> success
+- `400` / `413` -> drop
+- `401` -> unauthorized warning path
+- `429` / `500` -> retry with backoff
+- retriable batches are dropped after max retries
+
+---
+
+## Status
+
+This SDK is currently:
+
+- POC-focused
+- Under active development
+- Not production-ready
+- Subject to API changes
+
+---
+
+## Testing Conventions
+
+Unit tests must be co-located with the files they validate.
+
+Use either `.test.ts` or `.spec.ts` next to the implementation file, for example:
+
+```text
+src/
+  dirA/
+    file.ts
+    file.spec.ts
+  dirB/
+    otherFile.ts
+    otherFile.test.ts
+```
+
+Run tests with:
+
+```bash
+npm test
+```
+
+Run the explicit coverage gate locally with:
+
+```bash
+npm run test:coverage
+```
+
+---
+
+## Additional Documentation
+
+- Hardening and coverage matrix: `docs/hardening-and-testing.md`
+- Formatting and lint workflow: `docs/linting.md`
+
+## Local usage with `npm link`
+
+To run the package locally in other repositories, use `npm link`:
+
+Steps:
+
+1. In this repository:
+
+```
+npm link
+npm run build -- --watch
+```
+
+2. In the consuming repository:
+
+```
+npm link logscope
+```

package/dist/client/create-logscope-client.d.ts

@@ -0,0 +1,23 @@
+import { type DispatchConsoleLog } from '../console/capture-console';
+import type { ResolvedRuntimeConfig } from '../config/runtime-config';
+import { type BatchingPipeline } from '../pipeline/pipeline';
+import type { IngestionRequestResult } from '../transport/transport-types';
+import type { LogscopeClient, LogscopeConfig } from '../types';
+interface CreatePipelineInput {
+    ingestionBaseUrl: string;
+    apiKey: string;
+    runtimeConfig: ResolvedRuntimeConfig;
+    onBatchResult: (result: IngestionRequestResult) => void;
+}
+type CreatePipeline = (input: CreatePipelineInput) => BatchingPipeline;
+type WarnFn = (message: string) => void;
+type SetupConsoleCapture = (dispatchLog: DispatchConsoleLog) => void;
+interface CreateLogscopeClientDependencies {
+    createPipeline: CreatePipeline;
+    warn: WarnFn;
+    now: () => Date;
+    setupConsoleCapture?: SetupConsoleCapture;
+}
+export declare const createLogscopeClientInternal: (config: LogscopeConfig, dependencies: CreateLogscopeClientDependencies) => LogscopeClient;
+export declare const createLogscopeClient: (config: LogscopeConfig) => LogscopeClient;
+export {};

package/dist/client/create-logscope-client.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogscopeClient = exports.createLogscopeClientInternal = void 0;
+const capture_console_1 = require("../console/capture-console");
+const config_guards_1 = require("../config/config-guards");
+const pipeline_1 = require("../pipeline/pipeline");
+const pipeline_ingress_1 = require("../pipeline/pipeline-ingress");
+const send_ingestion_request_1 = require("../transport/send-ingestion-request");
+const log_methods_1 = require("./log-methods");
+const UNAUTHORIZED_WARNING_MESSAGE = '[logscope] Received unauthorized response (401). Check SDK API key configuration.';
+const RETRY_EXHAUSTED_WARNING_MESSAGE = '[logscope] Dropping log batch after max retry attempts.';
+const createNoopPipeline = () => {
+    return {
+        enqueue: () => { },
+        flushNow: async () => { },
+        stop: async () => { },
+    };
+};
+const createDefaultDependencies = () => {
+    const sendBatch = (input) => (0, send_ingestion_request_1.sendIngestionRequest)(input);
+    return {
+        createPipeline: (input) => (0, pipeline_1.createBatchingPipeline)({
+            endpoint: input.ingestionBaseUrl,
+            apiKey: input.apiKey,
+            sendBatch,
+            maxBatchSize: input.runtimeConfig.maxBatchSize,
+            flushIntervalMs: input.runtimeConfig.flushIntervalMs,
+            retryPolicy: input.runtimeConfig.retryPolicy,
+            onBatchResult: input.onBatchResult,
+        }),
+        warn: (message) => console.warn(message),
+        now: () => new Date(),
+        setupConsoleCapture: (dispatchLog) => {
+            (0, capture_console_1.captureConsole)({
+                dispatchLog,
+            });
+        },
+    };
+};
+const runSafeWarn = (warn, message) => {
+    try {
+        warn(message);
+    }
+    catch {
+        // Never throw into user code.
+    }
+};
+const createLogscopeClientInternal = (config, dependencies) => {
+    const guardedConfig = (0, config_guards_1.guardLogscopeClientConfig)(config);
+    let hasWarnedUnauthorized = false;
+    let hasWarnedRetryExhausted = false;
+    if (!guardedConfig.isValid) {
+        runSafeWarn(dependencies.warn, (0, config_guards_1.buildInvalidClientConfigWarning)(guardedConfig.invalidFields));
+    }
+    const pipeline = (() => {
+        if (!guardedConfig.isValid) {
+            return createNoopPipeline();
+        }
+        try {
+            return dependencies.createPipeline({
+                ingestionBaseUrl: guardedConfig.ingestionBaseUrl,
+                apiKey: guardedConfig.apiKey,
+                runtimeConfig: guardedConfig.runtimeConfig,
+                onBatchResult: (result) => {
+                    if (!result.shouldWarnUnauthorized || hasWarnedUnauthorized) {
+                        if (result.errorKind !== 'max_retries_exceeded' || hasWarnedRetryExhausted) {
+                            return;
+                        }
+                        hasWarnedRetryExhausted = true;
+                        runSafeWarn(dependencies.warn, RETRY_EXHAUSTED_WARNING_MESSAGE);
+                        return;
+                    }
+                    hasWarnedUnauthorized = true;
+                    runSafeWarn(dependencies.warn, UNAUTHORIZED_WARNING_MESSAGE);
+                },
+            });
+        }
+        catch {
+            return createNoopPipeline();
+        }
+    })();
+    const ingress = (0, pipeline_ingress_1.createPipelineIngress)({
+        source: guardedConfig.source,
+        logFilter: guardedConfig.logFilter,
+        now: dependencies.now,
+        pipeline,
+    });
+    const dispatchLog = (level, message, metadata) => {
+        ingress.dispatch({
+            level,
+            message,
+            metadata,
+        });
+    };
+    if (guardedConfig.captureConsole === true &&
+        guardedConfig.isValid &&
+        dependencies.setupConsoleCapture !== undefined) {
+        try {
+            dependencies.setupConsoleCapture(dispatchLog);
+        }
+        catch {
+            // Never throw into user code.
+        }
+    }
+    return (0, log_methods_1.createLogMethods)(dispatchLog);
+};
+exports.createLogscopeClientInternal = createLogscopeClientInternal;
+const createLogscopeClient = (config) => {
+    return (0, exports.createLogscopeClientInternal)(config, createDefaultDependencies());
+};
+exports.createLogscopeClient = createLogscopeClient;
+//# sourceMappingURL=create-logscope-client.js.map

package/dist/client/create-logscope-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-logscope-client.js","sourceRoot":"","sources":["../../src/client/create-logscope-client.ts"],"names":[],"mappings":"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"}

package/dist/client/log-methods.d.ts

@@ -0,0 +1,3 @@
+import type { LogLevel, LogscopeClient } from '../types';
+export type DispatchManualLog = (level: LogLevel, message: string, metadata?: unknown) => void;
+export declare const createLogMethods: (dispatchManualLog: DispatchManualLog) => LogscopeClient;

package/dist/client/log-methods.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogMethods = void 0;
+const createLogMethods = (dispatchManualLog) => {
+    return {
+        trace(message, metadata) {
+            dispatchManualLog('trace', message, metadata);
+        },
+        debug(message, metadata) {
+            dispatchManualLog('debug', message, metadata);
+        },
+        info(message, metadata) {
+            dispatchManualLog('info', message, metadata);
+        },
+        warn(message, metadata) {
+            dispatchManualLog('warn', message, metadata);
+        },
+        error(message, metadata) {
+            dispatchManualLog('error', message, metadata);
+        },
+        fatal(message, metadata) {
+            dispatchManualLog('fatal', message, metadata);
+        },
+    };
+};
+exports.createLogMethods = createLogMethods;
+//# sourceMappingURL=log-methods.js.map

package/dist/client/log-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-methods.js","sourceRoot":"","sources":["../../src/client/log-methods.ts"],"names":[],"mappings":";;;AAIO,MAAM,gBAAgB,GAAG,CAAC,iBAAoC,EAAkB,EAAE;IACvF,OAAO;QACL,KAAK,CAAC,OAAe,EAAE,QAAkB;YACvC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,CAAC,OAAe,EAAE,QAAkB;YACvC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAChD,CAAC;QACD,IAAI,CAAC,OAAe,EAAE,QAAkB;YACtC,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,OAAe,EAAE,QAAkB;YACtC,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC/C,CAAC;QACD,KAAK,CAAC,OAAe,EAAE,QAAkB;YACvC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,CAAC,OAAe,EAAE,QAAkB;YACvC,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAChD,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AArBW,QAAA,gBAAgB,oBAqB3B"}

package/dist/config/config-guards.d.ts

@@ -0,0 +1,31 @@
+import type { RetryPolicy } from '../retry/retry-policy';
+import { type ResolvedRuntimeConfig } from './runtime-config';
+import type { LogFilterConfig } from '../types';
+type ClientRequiredField = 'apiKey';
+type PinoRequiredField = 'apiKey' | 'endpoint' | 'source';
+interface GuardResult {
+    isValid: boolean;
+}
+export interface ClientConfigGuardResult extends GuardResult {
+    apiKey: string;
+    ingestionBaseUrl: string;
+    source: string;
+    captureConsole: boolean;
+    logFilter?: LogFilterConfig;
+    runtimeConfig: ResolvedRuntimeConfig;
+    invalidFields: ReadonlyArray<ClientRequiredField>;
+}
+export interface PinoOptionsGuardResult extends GuardResult {
+    apiKey: string;
+    endpoint: string;
+    source: string;
+    flushIntervalMs?: number;
+    retryPolicy?: Partial<RetryPolicy>;
+    logFilter?: LogFilterConfig;
+    invalidFields: ReadonlyArray<PinoRequiredField>;
+}
+export declare const buildInvalidClientConfigWarning: (invalidFields: ReadonlyArray<ClientRequiredField>) => string;
+export declare const buildInvalidPinoOptionsWarning: (invalidFields: ReadonlyArray<PinoRequiredField>) => string;
+export declare const guardLogscopeClientConfig: (config: unknown) => ClientConfigGuardResult;
+export declare const guardPinoTransportOptions: (options: unknown) => PinoOptionsGuardResult;
+export {};