@abbacchio/transport 0.1.1 → 0.1.3

package/README.md

@@ -0,0 +1,121 @@
+# @abbacchio/transport
+
+Node.js log transports for sending logs to [Abbacchio](https://github.com/pekonchan/pino-live) - a real-time log viewer dashboard.
+
+Supports **Pino**, **Winston**, **Bunyan**, and **Console**.
+
+## Installation
+
+```bash
+npm install @abbacchio/transport
+```
+
+## Usage
+
+### Pino
+
+```typescript
+import pino from "pino";
+
+const logger = pino({
+  transport: {
+    targets: [
+      { target: "pino-pretty" },
+      {
+        target: "@abbacchio/transport/transports/pino",
+        options: {
+          url: "http://localhost:4000/api/logs",
+          channel: "my-app",
+        },
+      },
+    ],
+  },
+});
+
+logger.info({ user: "john" }, "User logged in");
+```
+
+### Winston
+
+```typescript
+import winston from "winston";
+import { winstonTransport } from "@abbacchio/transport/transports/winston";
+
+const logger = winston.createLogger({
+  transports: [
+    new winston.transports.Console(),
+    winstonTransport({
+      url: "http://localhost:4000/api/logs",
+      channel: "my-app",
+    }),
+  ],
+});
+
+logger.info("User logged in", { user: "john" });
+```
+
+### Bunyan
+
+```typescript
+import bunyan from "bunyan";
+import { bunyanStream } from "@abbacchio/transport/transports/bunyan";
+
+const logger = bunyan.createLogger({
+  name: "myapp",
+  streams: [
+    { stream: process.stdout },
+    bunyanStream({
+      url: "http://localhost:4000/api/logs",
+      channel: "my-app",
+    }),
+  ],
+});
+
+logger.info({ user: "john" }, "User logged in");
+```
+
+### Console
+
+```typescript
+import { interceptConsole, restoreConsole } from "@abbacchio/transport/transports/console";
+
+interceptConsole({
+  url: "http://localhost:4000/api/logs",
+  channel: "my-app",
+  passthrough: true,
+});
+
+console.log("This will be sent to Abbacchio!");
+
+restoreConsole();
+```
+
+## Options
+
+| Option      | Type   | Default                          | Description                             |
+| ----------- | ------ | -------------------------------- | --------------------------------------- |
+| `url`       | string | `http://localhost:4000/api/logs` | Abbacchio server URL                    |
+| `channel`   | string | `default`                        | Channel name for multi-app support      |
+| `secretKey` | string | -                                | Encryption key (enables E2E encryption) |
+| `batchSize` | number | `10`                             | Send batch when this many logs accumulate |
+| `interval`  | number | `1000`                           | Send batch after this many ms           |
+| `headers`   | object | `{}`                             | Additional HTTP headers                 |
+
+## End-to-End Encryption
+
+Add `secretKey` to encrypt logs before sending:
+
+```typescript
+{
+  target: "@abbacchio/transport/transports/pino",
+  options: {
+    url: "http://localhost:4000/api/logs",
+    channel: "my-app",
+    secretKey: process.env.LOG_SECRET_KEY,
+  },
+}
+```
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abbacchio/transport",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Node.js log transports for Pino, Winston, and Bunyan - send logs to Abbacchio",
   "type": "module",
   "main": "dist/index.js",
@@ -10,8 +10,9 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./transports/pino": {
+    "./pino": {
       "types": "./dist/transports/pino.d.ts",
+      "require": "./pino-transport.cjs",
       "default": "./dist/transports/pino.js"
     },
     "./transports/winston": {
@@ -46,11 +47,24 @@
     "pino-abstract-transport": "^3.0.0",
     "winston-transport": "^4.9.0"
   },
+  "peerDependencies": {
+    "pino": "^8.0.0 || ^9.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pino": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/node": "^22.10.5",
+    "pino": "^9.0.0",
     "typescript": "^5.7.2"
   },
   "engines": {
     "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mood-agency/abbacchio"
   }
 }

package/pino-transport.cjs

@@ -0,0 +1,30 @@
+'use strict'
+
+/**
+ * CommonJS wrapper for the Pino transport.
+ *
+ * Pino runs transports in worker threads using require(), which doesn't
+ * work well with ESM subpath exports. This CJS wrapper allows users to
+ * simply use: target: '@abbacchio/transport'
+ *
+ * @example
+ * ```javascript
+ * const pino = require('pino');
+ *
+ * const logger = pino({
+ *   transport: {
+ *     target: '@abbacchio/transport',
+ *     options: {
+ *       url: 'http://localhost:4000/api/logs',
+ *       channel: 'my-app',
+ *     },
+ *   },
+ * });
+ * ```
+ */
+
+// Dynamic import the ESM module
+module.exports = async function(opts) {
+  const { default: pinoTransport } = await import('./dist/transports/pino.js');
+  return pinoTransport(opts);
+};

package/src/client.ts

@@ -1,148 +1,148 @@
-import { encrypt } from "./encrypt.js";
-
-export interface AbbacchioClientOptions {
-  /** Server URL endpoint */
-  url?: string;
-  /** Secret key for encryption. If provided, logs will be encrypted before sending */
-  secretKey?: string;
-  /** Channel/app name for multi-app support. Defaults to 'default' */
-  channel?: string;
-  /** Number of logs to batch before sending. Defaults to 10 */
-  batchSize?: number;
-  /** Interval in ms between flushes. Defaults to 1000 */
-  interval?: number;
-  /** Additional headers to send with requests */
-  headers?: Record<string, string>;
-}
-
-/**
- * Shared HTTP client for all Abbacchio transports.
- * Handles batching, encryption, and HTTP communication.
- */
-export class AbbacchioClient {
-  private url: string;
-  private secretKey?: string;
-  private channel?: string;
-  private batchSize: number;
-  private interval: number;
-  private headers: Record<string, string>;
-
-  private buffer: unknown[] = [];
-  private timer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor(options: AbbacchioClientOptions = {}) {
-    this.url = options.url || "http://localhost:4000/api/logs";
-    this.secretKey = options.secretKey;
-    this.channel = options.channel;
-    this.batchSize = options.batchSize || 10;
-    this.interval = options.interval || 1000;
-    this.headers = options.headers || {};
-  }
-
-  /**
-   * Process a log entry (encrypt if secretKey is provided)
-   */
-  private processLog(log: unknown): unknown {
-    if (this.secretKey) {
-      return { encrypted: encrypt(JSON.stringify(log), this.secretKey) };
-    }
-    return log;
-  }
-
-  /**
-   * Add a log to the buffer and trigger send if needed
-   */
-  add(log: unknown): void {
-    this.buffer.push(this.processLog(log));
-
-    if (this.buffer.length >= this.batchSize) {
-      this.flush();
-    } else {
-      this.scheduleSend();
-    }
-  }
-
-  /**
-   * Add multiple logs at once
-   */
-  addBatch(logs: unknown[]): void {
-    for (const log of logs) {
-      this.buffer.push(this.processLog(log));
-    }
-
-    if (this.buffer.length >= this.batchSize) {
-      this.flush();
-    } else {
-      this.scheduleSend();
-    }
-  }
-
-  /**
-   * Send logs immediately without batching
-   */
-  async send(logs: unknown[]): Promise<void> {
-    const processedLogs = logs.map(log => this.processLog(log));
-    await this.sendToServer(processedLogs);
-  }
-
-  /**
-   * Schedule a send after the interval
-   */
-  private scheduleSend(): void {
-    if (this.timer) return;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      this.flush();
-    }, this.interval);
-  }
-
-  /**
-   * Flush the buffer and send to server
-   */
-  async flush(): Promise<void> {
-    if (this.buffer.length === 0) return;
-
-    const toSend = this.buffer;
-    this.buffer = [];
-
-    await this.sendToServer(toSend);
-  }
-
-  /**
-   * Send logs to the Abbacchio server
-   */
-  private async sendToServer(logs: unknown[]): Promise<void> {
-    try {
-      await fetch(this.url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Encrypted": this.secretKey ? "true" : "false",
-          ...(this.channel ? { "X-Channel": this.channel } : {}),
-          ...this.headers,
-        },
-        body: JSON.stringify({ logs }),
-      });
-    } catch {
-      // Silently fail - don't break the app if Abbacchio server is down
-    }
-  }
-
-  /**
-   * Close the client and flush any remaining logs
-   */
-  async close(): Promise<void> {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    await this.flush();
-  }
-}
-
-/**
- * Create a new Abbacchio client instance
- */
-export function createClient(options?: AbbacchioClientOptions): AbbacchioClient {
-  return new AbbacchioClient(options);
-}
+import { encrypt } from "./encrypt.js";
+
+export interface AbbacchioClientOptions {
+  /** Server URL endpoint */
+  url?: string;
+  /** Secret key for encryption. If provided, logs will be encrypted before sending */
+  secretKey?: string;
+  /** Channel/app name for multi-app support. Defaults to 'default' */
+  channel?: string;
+  /** Number of logs to batch before sending. Defaults to 10 */
+  batchSize?: number;
+  /** Interval in ms between flushes. Defaults to 1000 */
+  interval?: number;
+  /** Additional headers to send with requests */
+  headers?: Record<string, string>;
+}
+
+/**
+ * Shared HTTP client for all Abbacchio transports.
+ * Handles batching, encryption, and HTTP communication.
+ */
+export class AbbacchioClient {
+  private url: string;
+  private secretKey?: string;
+  private channel?: string;
+  private batchSize: number;
+  private interval: number;
+  private headers: Record<string, string>;
+
+  private buffer: unknown[] = [];
+  private timer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(options: AbbacchioClientOptions = {}) {
+    this.url = options.url || "http://localhost:4000/api/logs";
+    this.secretKey = options.secretKey;
+    this.channel = options.channel;
+    this.batchSize = options.batchSize || 10;
+    this.interval = options.interval || 1000;
+    this.headers = options.headers || {};
+  }
+
+  /**
+   * Process a log entry (encrypt if secretKey is provided)
+   */
+  private processLog(log: unknown): unknown {
+    if (this.secretKey) {
+      return { encrypted: encrypt(JSON.stringify(log), this.secretKey) };
+    }
+    return log;
+  }
+
+  /**
+   * Add a log to the buffer and trigger send if needed
+   */
+  add(log: unknown): void {
+    this.buffer.push(this.processLog(log));
+
+    if (this.buffer.length >= this.batchSize) {
+      this.flush();
+    } else {
+      this.scheduleSend();
+    }
+  }
+
+  /**
+   * Add multiple logs at once
+   */
+  addBatch(logs: unknown[]): void {
+    for (const log of logs) {
+      this.buffer.push(this.processLog(log));
+    }
+
+    if (this.buffer.length >= this.batchSize) {
+      this.flush();
+    } else {
+      this.scheduleSend();
+    }
+  }
+
+  /**
+   * Send logs immediately without batching
+   */
+  async send(logs: unknown[]): Promise<void> {
+    const processedLogs = logs.map(log => this.processLog(log));
+    await this.sendToServer(processedLogs);
+  }
+
+  /**
+   * Schedule a send after the interval
+   */
+  private scheduleSend(): void {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush();
+    }, this.interval);
+  }
+
+  /**
+   * Flush the buffer and send to server
+   */
+  async flush(): Promise<void> {
+    if (this.buffer.length === 0) return;
+
+    const toSend = this.buffer;
+    this.buffer = [];
+
+    await this.sendToServer(toSend);
+  }
+
+  /**
+   * Send logs to the Abbacchio server
+   */
+  private async sendToServer(logs: unknown[]): Promise<void> {
+    try {
+      await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Encrypted": this.secretKey ? "true" : "false",
+          ...(this.channel ? { "X-Channel": this.channel } : {}),
+          ...this.headers,
+        },
+        body: JSON.stringify({ logs }),
+      });
+    } catch {
+      // Silently fail - don't break the app if Abbacchio server is down
+    }
+  }
+
+  /**
+   * Close the client and flush any remaining logs
+   */
+  async close(): Promise<void> {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+}
+
+/**
+ * Create a new Abbacchio client instance
+ */
+export function createClient(options?: AbbacchioClientOptions): AbbacchioClient {
+  return new AbbacchioClient(options);
+}