@fabbahiense/pulsar-pino-transport 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @pulsar/pino-transport
+
+Pino transport for [Pulsar](https://github.com/your-org/pulsar) — send your application logs to Pulsar in real-time.
+
+## Install
+
+```bash
+npm install @pulsar/pino-transport
+```
+
+## Usage
+
+```typescript
+import pino from 'pino'
+
+const logger = pino({
+  transport: {
+    target: '@pulsar/pino-transport',
+    options: {
+      url: 'https://your-pulsar-instance.com',
+      apiKey: 'psk_your_api_key',
+      source: 'my-api',        // optional, default: 'default'
+      batchSize: 50,            // optional, default: 50
+      flushInterval: 2000,      // optional, default: 2000ms
+    },
+  },
+})
+
+logger.info('Server started')
+logger.error({ traceId: 'abc-123' }, 'Something went wrong')
+```
+
+## Features
+
+- Batched log delivery (configurable batch size)
+- Automatic retry with exponential backoff (3 attempts)
+- In-memory queue — no logs lost on temporary network failures
+- Zero dependencies (uses native `fetch`)
+- TypeScript types included
+- Dual CJS/ESM package
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `url` | `string` | — | Pulsar server URL (required) |
+| `apiKey` | `string` | — | API key for authentication (required) |
+| `source` | `string` | `'default'` | Service name in Pulsar |
+| `batchSize` | `number` | `50` | Logs buffered before flush |
+| `flushInterval` | `number` | `2000` | Flush interval in ms |
+
+## Trace ID
+
+The transport automatically picks up trace IDs from these fields:
+
+- `traceId`
+- `trace_id`
+- `requestId`
+- `req.id`
+
+```typescript
+logger.info({ traceId: 'my-trace-id' }, 'Processing request')
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,150 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createPulsarTransport: () => createPulsarTransport,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var LEVEL_MAP = {
+  10: "trace",
+  20: "debug",
+  30: "info",
+  40: "warn",
+  50: "error",
+  60: "fatal"
+};
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS = 1e3;
+function parseTimestamp(time) {
+  if (!time) return Date.now();
+  if (typeof time === "number") return time;
+  if (/^\d{13}$/.test(time)) return parseInt(time, 10);
+  const parsed = new Date(time).getTime();
+  return isNaN(parsed) ? Date.now() : parsed;
+}
+async function flushWithRetry(url, apiKey, batch, retryQueue) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`
+  };
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      const res = await fetch(`${url}/api/ingest/batch`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ logs: batch })
+      });
+      if (res.ok) return;
+      if (res.status >= 400 && res.status < 500) return;
+    } catch {
+    }
+    if (attempt < MAX_RETRIES - 1) {
+      const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  retryQueue.push(...batch);
+}
+function createPulsarTransport(options) {
+  const {
+    url,
+    apiKey,
+    source,
+    serviceName,
+    batchSize = 50,
+    flushInterval = 2e3
+  } = options;
+  const resolvedSource = source || serviceName || "default";
+  return {
+    transport: {
+      target: "@pulsar/pino-transport",
+      options: { url, apiKey, source: resolvedSource, batchSize, flushInterval }
+    }
+  };
+}
+async function index_default(options) {
+  const {
+    url = "http://localhost:4000",
+    apiKey = "",
+    source,
+    serviceName,
+    batchSize = 50,
+    flushInterval = 2e3
+  } = options;
+  const resolvedSource = source || serviceName || "default";
+  const { default: build } = await import("pino-abstract-transport");
+  const buffer = [];
+  const retryQueue = [];
+  let timer = null;
+  async function flush() {
+    if (retryQueue.length > 0) {
+      buffer.unshift(...retryQueue.splice(0));
+    }
+    if (buffer.length === 0) return;
+    const batch = buffer.splice(0, batchSize);
+    await flushWithRetry(url, apiKey, batch, retryQueue);
+  }
+  return build(async function(stream) {
+    for await (const obj of stream) {
+      buffer.push({
+        level: LEVEL_MAP[obj.level] || "info",
+        msg: obj.msg,
+        timestamp: parseTimestamp(obj.time),
+        serviceName: resolvedSource,
+        traceId: obj.traceId || obj.trace_id || obj.requestId || obj.req?.id || null,
+        method: obj.req?.method,
+        url: obj.req?.url,
+        statusCode: obj.res?.statusCode,
+        responseTime: obj.responseTime,
+        errorMessage: obj.err?.message,
+        errorStack: obj.err?.stack,
+        metadata: obj.metadata || null
+      });
+      if (buffer.length >= batchSize) {
+        await flush();
+      }
+      if (!timer) {
+        timer = setInterval(() => flush(), flushInterval);
+      }
+    }
+    if (timer) clearInterval(timer);
+    await flush();
+    if (retryQueue.length > 0) {
+      buffer.push(...retryQueue.splice(0));
+      await flush();
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPulsarTransport
+});

package/dist/index.d.cts

@@ -0,0 +1,50 @@
+import * as pino_abstract_transport from 'pino-abstract-transport';
+import * as node_stream from 'node:stream';
+
+interface PulsarTransportOptions {
+    /** Pulsar server URL (e.g., 'https://pulsar.example.com') */
+    url: string;
+    /** API key for authentication (psk_...) */
+    apiKey: string;
+    /** Service name that will appear in Pulsar (default: 'default') */
+    source?: string;
+    /** Alias for source */
+    serviceName?: string;
+    /** Number of logs to buffer before flushing (default: 50) */
+    batchSize?: number;
+    /** Flush interval in milliseconds (default: 2000) */
+    flushInterval?: number;
+}
+/**
+ * Creates a Pino transport that sends logs to a Pulsar server.
+ *
+ * @example
+ * ```ts
+ * import pino from 'pino'
+ * import { createPulsarTransport } from '@pulsar/pino-transport'
+ *
+ * const logger = pino(
+ *   createPulsarTransport({
+ *     url: 'https://pulsar.example.com',
+ *     apiKey: 'psk_...',
+ *   })
+ * )
+ *
+ * logger.info('Server started')
+ * ```
+ */
+declare function createPulsarTransport(options: PulsarTransportOptions): {
+    transport: {
+        target: string;
+        options: {
+            url: string;
+            apiKey: string;
+            source: string;
+            batchSize: number;
+            flushInterval: number;
+        };
+    };
+};
+declare function export_default(options: PulsarTransportOptions): Promise<node_stream.Transform & pino_abstract_transport.OnUnknown>;
+
+export { type PulsarTransportOptions, createPulsarTransport, export_default as default };

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import * as pino_abstract_transport from 'pino-abstract-transport';
+import * as node_stream from 'node:stream';
+
+interface PulsarTransportOptions {
+    /** Pulsar server URL (e.g., 'https://pulsar.example.com') */
+    url: string;
+    /** API key for authentication (psk_...) */
+    apiKey: string;
+    /** Service name that will appear in Pulsar (default: 'default') */
+    source?: string;
+    /** Alias for source */
+    serviceName?: string;
+    /** Number of logs to buffer before flushing (default: 50) */
+    batchSize?: number;
+    /** Flush interval in milliseconds (default: 2000) */
+    flushInterval?: number;
+}
+/**
+ * Creates a Pino transport that sends logs to a Pulsar server.
+ *
+ * @example
+ * ```ts
+ * import pino from 'pino'
+ * import { createPulsarTransport } from '@pulsar/pino-transport'
+ *
+ * const logger = pino(
+ *   createPulsarTransport({
+ *     url: 'https://pulsar.example.com',
+ *     apiKey: 'psk_...',
+ *   })
+ * )
+ *
+ * logger.info('Server started')
+ * ```
+ */
+declare function createPulsarTransport(options: PulsarTransportOptions): {
+    transport: {
+        target: string;
+        options: {
+            url: string;
+            apiKey: string;
+            source: string;
+            batchSize: number;
+            flushInterval: number;
+        };
+    };
+};
+declare function export_default(options: PulsarTransportOptions): Promise<node_stream.Transform & pino_abstract_transport.OnUnknown>;
+
+export { type PulsarTransportOptions, createPulsarTransport, export_default as default };

package/dist/index.js

@@ -0,0 +1,115 @@
+// src/index.ts
+var LEVEL_MAP = {
+  10: "trace",
+  20: "debug",
+  30: "info",
+  40: "warn",
+  50: "error",
+  60: "fatal"
+};
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS = 1e3;
+function parseTimestamp(time) {
+  if (!time) return Date.now();
+  if (typeof time === "number") return time;
+  if (/^\d{13}$/.test(time)) return parseInt(time, 10);
+  const parsed = new Date(time).getTime();
+  return isNaN(parsed) ? Date.now() : parsed;
+}
+async function flushWithRetry(url, apiKey, batch, retryQueue) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${apiKey}`
+  };
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      const res = await fetch(`${url}/api/ingest/batch`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ logs: batch })
+      });
+      if (res.ok) return;
+      if (res.status >= 400 && res.status < 500) return;
+    } catch {
+    }
+    if (attempt < MAX_RETRIES - 1) {
+      const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  retryQueue.push(...batch);
+}
+function createPulsarTransport(options) {
+  const {
+    url,
+    apiKey,
+    source,
+    serviceName,
+    batchSize = 50,
+    flushInterval = 2e3
+  } = options;
+  const resolvedSource = source || serviceName || "default";
+  return {
+    transport: {
+      target: "@pulsar/pino-transport",
+      options: { url, apiKey, source: resolvedSource, batchSize, flushInterval }
+    }
+  };
+}
+async function index_default(options) {
+  const {
+    url = "http://localhost:4000",
+    apiKey = "",
+    source,
+    serviceName,
+    batchSize = 50,
+    flushInterval = 2e3
+  } = options;
+  const resolvedSource = source || serviceName || "default";
+  const { default: build } = await import("pino-abstract-transport");
+  const buffer = [];
+  const retryQueue = [];
+  let timer = null;
+  async function flush() {
+    if (retryQueue.length > 0) {
+      buffer.unshift(...retryQueue.splice(0));
+    }
+    if (buffer.length === 0) return;
+    const batch = buffer.splice(0, batchSize);
+    await flushWithRetry(url, apiKey, batch, retryQueue);
+  }
+  return build(async function(stream) {
+    for await (const obj of stream) {
+      buffer.push({
+        level: LEVEL_MAP[obj.level] || "info",
+        msg: obj.msg,
+        timestamp: parseTimestamp(obj.time),
+        serviceName: resolvedSource,
+        traceId: obj.traceId || obj.trace_id || obj.requestId || obj.req?.id || null,
+        method: obj.req?.method,
+        url: obj.req?.url,
+        statusCode: obj.res?.statusCode,
+        responseTime: obj.responseTime,
+        errorMessage: obj.err?.message,
+        errorStack: obj.err?.stack,
+        metadata: obj.metadata || null
+      });
+      if (buffer.length >= batchSize) {
+        await flush();
+      }
+      if (!timer) {
+        timer = setInterval(() => flush(), flushInterval);
+      }
+    }
+    if (timer) clearInterval(timer);
+    await flush();
+    if (retryQueue.length > 0) {
+      buffer.push(...retryQueue.splice(0));
+      await flush();
+    }
+  });
+}
+export {
+  createPulsarTransport,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@fabbahiense/pulsar-pino-transport",
+  "version": "0.1.0",
+  "description": "Pino transport for Pulsar observability platform",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "peerDependencies": {
+    "pino-abstract-transport": ">=2.0.0"
+  },
+  "devDependencies": {
+    "pino-abstract-transport": "^3.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.0"
+  },
+  "keywords": ["pino", "transport", "pulsar", "observability", "logging"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}