@mastra/loggers 0.10.2 → 0.10.3

package/README.md

@@ -129,7 +129,6 @@ interface BaseLogMessage {
 Both transports include robust error handling:
 
 - File Transport:
-
   - Validates file path existence
   - Handles stream errors
   - Graceful cleanup on destroy

package/dist/_tsup-dts-rollup.d.cts

@@ -47,6 +47,68 @@ export declare class FileTransport extends LoggerTransport {
     }>;
 }
 
+export declare class HttpTransport extends LoggerTransport {
+    private url;
+    private method;
+    private headers;
+    private batchSize;
+    private flushInterval;
+    private timeout;
+    private retryOptions;
+    private logBuffer;
+    private lastFlush;
+    private flushIntervalId;
+    constructor(options: HttpTransportOptions);
+    private makeHttpRequest;
+    _flush(): Promise<void>;
+    _write(chunk: any, encoding?: string, callback?: (error?: Error | null) => void): boolean;
+    _transform(chunk: string, _enc: string, cb: Function): void;
+    _destroy(err: Error, cb: Function): void;
+    getLogs(params?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        returnPaginationResults?: boolean;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    getLogsByRunId({ runId: _runId, fromDate: _fromDate, toDate: _toDate, logLevel: _logLevel, filters: _filters, page, perPage, }: {
+        runId: string;
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    getBufferedLogs(): BaseLogMessage[];
+    clearBuffer(): void;
+    getLastFlushTime(): number;
+}
+
+declare interface HttpTransportOptions {
+    url: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    batchSize?: number;
+    flushInterval?: number;
+    timeout?: number;
+    retryOptions?: RetryOptions;
+}
+
 export { LogLevel }
 export { LogLevel as LogLevel_alias_1 }
 
@@ -57,6 +119,7 @@ declare class PinoLogger extends MastraLogger {
         level?: LogLevel;
         transports?: TransportMap;
         overrideDefaultTransports?: boolean;
+        formatters?: pino.LoggerOptions['formatters'];
     });
     debug(message: string, args?: Record<string, any>): void;
     info(message: string, args?: Record<string, any>): void;
@@ -66,6 +129,12 @@ declare class PinoLogger extends MastraLogger {
 export { PinoLogger }
 export { PinoLogger as PinoLogger_alias_1 }
 
+declare interface RetryOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+}
+
 declare type TransportMap = Record<string, LoggerTransport>;
 
 export declare class UpstashTransport extends LoggerTransport {

package/dist/_tsup-dts-rollup.d.ts

@@ -47,6 +47,68 @@ export declare class FileTransport extends LoggerTransport {
     }>;
 }
 
+export declare class HttpTransport extends LoggerTransport {
+    private url;
+    private method;
+    private headers;
+    private batchSize;
+    private flushInterval;
+    private timeout;
+    private retryOptions;
+    private logBuffer;
+    private lastFlush;
+    private flushIntervalId;
+    constructor(options: HttpTransportOptions);
+    private makeHttpRequest;
+    _flush(): Promise<void>;
+    _write(chunk: any, encoding?: string, callback?: (error?: Error | null) => void): boolean;
+    _transform(chunk: string, _enc: string, cb: Function): void;
+    _destroy(err: Error, cb: Function): void;
+    getLogs(params?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        returnPaginationResults?: boolean;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    getLogsByRunId({ runId: _runId, fromDate: _fromDate, toDate: _toDate, logLevel: _logLevel, filters: _filters, page, perPage, }: {
+        runId: string;
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: Record<string, any>;
+        page?: number;
+        perPage?: number;
+    }): Promise<{
+        logs: BaseLogMessage[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasMore: boolean;
+    }>;
+    getBufferedLogs(): BaseLogMessage[];
+    clearBuffer(): void;
+    getLastFlushTime(): number;
+}
+
+declare interface HttpTransportOptions {
+    url: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    batchSize?: number;
+    flushInterval?: number;
+    timeout?: number;
+    retryOptions?: RetryOptions;
+}
+
 export { LogLevel }
 export { LogLevel as LogLevel_alias_1 }
 
@@ -57,6 +119,7 @@ declare class PinoLogger extends MastraLogger {
         level?: LogLevel;
         transports?: TransportMap;
         overrideDefaultTransports?: boolean;
+        formatters?: pino.LoggerOptions['formatters'];
     });
     debug(message: string, args?: Record<string, any>): void;
     info(message: string, args?: Record<string, any>): void;
@@ -66,6 +129,12 @@ declare class PinoLogger extends MastraLogger {
 export { PinoLogger }
 export { PinoLogger as PinoLogger_alias_1 }
 
+declare interface RetryOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+}
+
 declare type TransportMap = Record<string, LoggerTransport>;
 
 export declare class UpstashTransport extends LoggerTransport {

package/dist/http/index.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+var logger = require('@mastra/core/logger');
+
+// src/http/index.ts
+var HttpTransport = class extends logger.LoggerTransport {
+  url;
+  method;
+  headers;
+  batchSize;
+  flushInterval;
+  timeout;
+  retryOptions;
+  logBuffer;
+  lastFlush;
+  flushIntervalId;
+  constructor(options) {
+    super({ objectMode: true });
+    if (!options.url) {
+      throw new Error("HTTP URL is required");
+    }
+    this.url = options.url;
+    this.method = options.method || "POST";
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    this.batchSize = options.batchSize || 100;
+    this.flushInterval = options.flushInterval || 1e4;
+    this.timeout = options.timeout || 3e4;
+    this.retryOptions = {
+      maxRetries: options.retryOptions?.maxRetries || 3,
+      retryDelay: options.retryOptions?.retryDelay || 1e3,
+      exponentialBackoff: options.retryOptions?.exponentialBackoff || true
+    };
+    this.logBuffer = [];
+    this.lastFlush = Date.now();
+    this.flushIntervalId = setInterval(() => {
+      this._flush().catch((err) => {
+        console.error("Error flushing logs to HTTP endpoint:", err);
+      });
+    }, this.flushInterval);
+  }
+  async makeHttpRequest(data, retryCount = 0) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const body = JSON.stringify({ logs: data });
+      const response = await fetch(this.url, {
+        method: this.method,
+        headers: this.headers,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (retryCount < this.retryOptions.maxRetries) {
+        const delay = this.retryOptions.exponentialBackoff ? this.retryOptions.retryDelay * Math.pow(2, retryCount) : this.retryOptions.retryDelay;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.makeHttpRequest(data, retryCount + 1);
+      }
+      throw error;
+    }
+  }
+  async _flush() {
+    if (this.logBuffer.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    const logs = this.logBuffer.splice(0, this.batchSize);
+    try {
+      await this.makeHttpRequest(logs);
+      this.lastFlush = now;
+    } catch (error) {
+      this.logBuffer.unshift(...logs);
+      throw error;
+    }
+  }
+  _write(chunk, encoding, callback) {
+    if (typeof callback === "function") {
+      this._transform(chunk, encoding || "utf8", callback);
+      return true;
+    }
+    this._transform(chunk, encoding || "utf8", (error) => {
+      if (error) console.error("Transform error in write:", error);
+    });
+    return true;
+  }
+  _transform(chunk, _enc, cb) {
+    try {
+      const log = typeof chunk === "string" ? JSON.parse(chunk) : chunk;
+      if (!log.time) {
+        log.time = Date.now();
+      }
+      this.logBuffer.push(log);
+      if (this.logBuffer.length >= this.batchSize) {
+        this._flush().catch((err) => {
+          console.error("Error flushing logs to HTTP endpoint:", err);
+        });
+      }
+      cb(null, chunk);
+    } catch (error) {
+      cb(error);
+    }
+  }
+  _destroy(err, cb) {
+    clearInterval(this.flushIntervalId);
+    if (this.logBuffer.length > 0) {
+      this._flush().then(() => cb(err)).catch((flushErr) => {
+        console.error("Error in final flush:", flushErr);
+        cb(err || flushErr);
+      });
+    } else {
+      cb(err);
+    }
+  }
+  async getLogs(params) {
+    console.warn(
+      "HttpTransport.getLogs: This transport is write-only. Override this method to implement log retrieval."
+    );
+    return {
+      logs: [],
+      total: 0,
+      page: params?.page ?? 1,
+      perPage: params?.perPage ?? 100,
+      hasMore: false
+    };
+  }
+  async getLogsByRunId({
+    runId: _runId,
+    fromDate: _fromDate,
+    toDate: _toDate,
+    logLevel: _logLevel,
+    filters: _filters,
+    page,
+    perPage
+  }) {
+    console.warn(
+      "HttpTransport.getLogsByRunId: This transport is write-only. Override this method to implement log retrieval."
+    );
+    return {
+      logs: [],
+      total: 0,
+      page: page ?? 1,
+      perPage: perPage ?? 100,
+      hasMore: false
+    };
+  }
+  // Utility methods
+  getBufferedLogs() {
+    return [...this.logBuffer];
+  }
+  clearBuffer() {
+    this.logBuffer = [];
+  }
+  getLastFlushTime() {
+    return this.lastFlush;
+  }
+};
+
+exports.HttpTransport = HttpTransport;

package/dist/http/index.d.cts

@@ -0,0 +1 @@
+export { HttpTransport } from '../_tsup-dts-rollup.cjs';

package/dist/http/index.d.ts

@@ -0,0 +1 @@
+export { HttpTransport } from '../_tsup-dts-rollup.js';

package/dist/http/index.js

@@ -0,0 +1,164 @@
+import { LoggerTransport } from '@mastra/core/logger';
+
+// src/http/index.ts
+var HttpTransport = class extends LoggerTransport {
+  url;
+  method;
+  headers;
+  batchSize;
+  flushInterval;
+  timeout;
+  retryOptions;
+  logBuffer;
+  lastFlush;
+  flushIntervalId;
+  constructor(options) {
+    super({ objectMode: true });
+    if (!options.url) {
+      throw new Error("HTTP URL is required");
+    }
+    this.url = options.url;
+    this.method = options.method || "POST";
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    this.batchSize = options.batchSize || 100;
+    this.flushInterval = options.flushInterval || 1e4;
+    this.timeout = options.timeout || 3e4;
+    this.retryOptions = {
+      maxRetries: options.retryOptions?.maxRetries || 3,
+      retryDelay: options.retryOptions?.retryDelay || 1e3,
+      exponentialBackoff: options.retryOptions?.exponentialBackoff || true
+    };
+    this.logBuffer = [];
+    this.lastFlush = Date.now();
+    this.flushIntervalId = setInterval(() => {
+      this._flush().catch((err) => {
+        console.error("Error flushing logs to HTTP endpoint:", err);
+      });
+    }, this.flushInterval);
+  }
+  async makeHttpRequest(data, retryCount = 0) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const body = JSON.stringify({ logs: data });
+      const response = await fetch(this.url, {
+        method: this.method,
+        headers: this.headers,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (retryCount < this.retryOptions.maxRetries) {
+        const delay = this.retryOptions.exponentialBackoff ? this.retryOptions.retryDelay * Math.pow(2, retryCount) : this.retryOptions.retryDelay;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this.makeHttpRequest(data, retryCount + 1);
+      }
+      throw error;
+    }
+  }
+  async _flush() {
+    if (this.logBuffer.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    const logs = this.logBuffer.splice(0, this.batchSize);
+    try {
+      await this.makeHttpRequest(logs);
+      this.lastFlush = now;
+    } catch (error) {
+      this.logBuffer.unshift(...logs);
+      throw error;
+    }
+  }
+  _write(chunk, encoding, callback) {
+    if (typeof callback === "function") {
+      this._transform(chunk, encoding || "utf8", callback);
+      return true;
+    }
+    this._transform(chunk, encoding || "utf8", (error) => {
+      if (error) console.error("Transform error in write:", error);
+    });
+    return true;
+  }
+  _transform(chunk, _enc, cb) {
+    try {
+      const log = typeof chunk === "string" ? JSON.parse(chunk) : chunk;
+      if (!log.time) {
+        log.time = Date.now();
+      }
+      this.logBuffer.push(log);
+      if (this.logBuffer.length >= this.batchSize) {
+        this._flush().catch((err) => {
+          console.error("Error flushing logs to HTTP endpoint:", err);
+        });
+      }
+      cb(null, chunk);
+    } catch (error) {
+      cb(error);
+    }
+  }
+  _destroy(err, cb) {
+    clearInterval(this.flushIntervalId);
+    if (this.logBuffer.length > 0) {
+      this._flush().then(() => cb(err)).catch((flushErr) => {
+        console.error("Error in final flush:", flushErr);
+        cb(err || flushErr);
+      });
+    } else {
+      cb(err);
+    }
+  }
+  async getLogs(params) {
+    console.warn(
+      "HttpTransport.getLogs: This transport is write-only. Override this method to implement log retrieval."
+    );
+    return {
+      logs: [],
+      total: 0,
+      page: params?.page ?? 1,
+      perPage: params?.perPage ?? 100,
+      hasMore: false
+    };
+  }
+  async getLogsByRunId({
+    runId: _runId,
+    fromDate: _fromDate,
+    toDate: _toDate,
+    logLevel: _logLevel,
+    filters: _filters,
+    page,
+    perPage
+  }) {
+    console.warn(
+      "HttpTransport.getLogsByRunId: This transport is write-only. Override this method to implement log retrieval."
+    );
+    return {
+      logs: [],
+      total: 0,
+      page: page ?? 1,
+      perPage: perPage ?? 100,
+      hasMore: false
+    };
+  }
+  // Utility methods
+  getBufferedLogs() {
+    return [...this.logBuffer];
+  }
+  clearBuffer() {
+    this.logBuffer = [];
+  }
+  getLastFlushTime() {
+    return this.lastFlush;
+  }
+};
+
+export { HttpTransport };

package/dist/index.cjs

@@ -30,9 +30,7 @@ var PinoLogger = class extends logger.MastraLogger {
       {
         name: options.name || "app",
         level: options.level || logger.LogLevel.INFO,
-        formatters: {
-          level: (label) => ({ level: label })
-        }
+        formatters: options.formatters
       },
       options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? prettyStream : pino__default.default.multistream([
         ...transportsAry.map(([, transport]) => ({

package/dist/index.js

@@ -23,9 +23,7 @@ var PinoLogger = class extends MastraLogger {
       {
         name: options.name || "app",
         level: options.level || LogLevel.INFO,
-        formatters: {
-          level: (label) => ({ level: label })
-        }
+        formatters: options.formatters
       },
       options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? prettyStream : pino.multistream([
         ...transportsAry.map(([, transport]) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/loggers",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "",
   "type": "module",
   "files": [
@@ -39,6 +39,16 @@
         "default": "./dist/upstash/index.cjs"
       }
     },
+    "./http": {
+      "import": {
+        "types": "./dist/http/index.d.ts",
+        "default": "./dist/http/index.js"
+      },
+      "require": {
+        "types": "./dist/http/index.d.cts",
+        "default": "./dist/http/index.cjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "keywords": [],
@@ -50,19 +60,19 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
-    "eslint": "^9.28.0",
+    "@types/node": "^20.19.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@internal/lint": "0.0.11",
-    "@mastra/core": "0.10.4"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.17",
+    "@mastra/core": "0.10.10"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/file/index.ts src/upstash/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
+    "build": "tsup src/index.ts src/file/index.ts src/upstash/index.ts src/http/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "build:watch": "pnpm build --watch",
     "test": "vitest run",
     "lint": "eslint ."