@mastra/loggers 0.0.0-commonjs-20250227130920

package/eslint.config.js

@@ -0,0 +1,6 @@
+import { createConfig } from '@internal/lint/eslint';
+
+const config = await createConfig();
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...config];

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@mastra/loggers",
+  "version": "0.0.0-commonjs-20250227130920",
+  "description": "",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./file": {
+      "import": {
+        "types": "./dist/file/index.d.ts",
+        "default": "./dist/file/index.js"
+      },
+      "require": {
+        "types": "./dist/file/index.d.cts",
+        "default": "./dist/file/index.cjs"
+      }
+    },
+    "./upstash": {
+      "import": {
+        "types": "./dist/upstash/index.d.ts",
+        "default": "./dist/upstash/index.js"
+      },
+      "require": {
+        "types": "./dist/upstash/index.d.cts",
+        "default": "./dist/upstash/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@mastra/core": "^0.0.0-commonjs-20250227130920"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.49.2",
+    "@types/node": "^22.13.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4",
+    "eslint": "^9.20.1",
+    "@internal/lint": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/file/index.ts src/upstash/index.ts --format esm,cjs --experimental-dts --clean --treeshake",
+    "build:watch": "pnpm build --watch",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
+}

package/src/file/index.test.ts

@@ -0,0 +1,130 @@
+import fs from 'fs';
+import path from 'path';
+import { createLogger, LogLevel } from '@mastra/core/logger';
+import { describe, it, expect, beforeEach, vi, afterAll } from 'vitest';
+
+import { FileTransport } from './index.js';
+
+describe('FileTransport', () => {
+  const testDir = __dirname + '/fixtures';
+  const testFile = 'test.log';
+  const testPath = path.join(testDir, testFile);
+  let fileLogger: FileTransport;
+
+  beforeEach(async () => {
+    // Create test directory
+    if (!fs.existsSync(testDir)) {
+      fs.mkdirSync(testDir);
+    }
+    fileLogger = new FileTransport({ path: testPath });
+  });
+
+  afterAll(async () => {
+    // Cleanup test directory
+    fs.writeFileSync(testPath, ``);
+  });
+
+  it('should create a file stream when instantiated', () => {
+    expect(fileLogger.fileStream).toBeDefined();
+    expect(fileLogger.path).toBe(testPath);
+  });
+
+  it('should work with createLogger', async () => {
+    const logger = createLogger({
+      name: 'test-logger',
+      level: LogLevel.INFO,
+      transports: {
+        file: fileLogger,
+      },
+    });
+
+    const testMessage = 'test info message';
+    logger.info(testMessage);
+
+    // Wait for file write to complete
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    const fileContent = fs.readFileSync(testPath, 'utf8');
+    expect(fileContent).toContain(testMessage);
+  });
+
+  it('should handle multiple log messages', async () => {
+    const logger = createLogger({
+      name: 'test-logger',
+      level: LogLevel.INFO,
+      transports: {
+        file: fileLogger,
+      },
+    });
+
+    const messages = ['message1', 'message2', 'message3'];
+    messages.forEach(msg => logger.info(msg));
+
+    // Wait for file writes to complete
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    const fileContent = fs.readFileSync(testPath, 'utf8');
+    messages.forEach(msg => {
+      expect(fileContent).toContain(msg);
+    });
+  });
+
+  it('should properly clean up resources on destroy', () => {
+    const destroySpy = vi.spyOn(fileLogger.fileStream, 'destroy');
+
+    fileLogger._destroy(new Error('test'), () => {
+      expect(destroySpy).toHaveBeenCalled();
+    });
+  });
+
+  it('should handle errors in _transform', () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const errorObj = new Error('Test error');
+
+    vi.spyOn(fileLogger.fileStream, 'write').mockImplementationOnce(() => {
+      throw errorObj;
+    });
+
+    fileLogger._transform('test', 'utf8', error => {
+      expect(consoleSpy).toHaveBeenCalledWith('Error parsing log entry:', errorObj);
+      expect(error).toBeNull(); // Should not propagate error
+    });
+  });
+
+  it('should flush remaining data when stream ends', () => {
+    const endSpy = vi.spyOn(fileLogger.fileStream, 'end');
+
+    fileLogger._flush(() => {
+      expect(endSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('getLogs and getLogsByRunId', () => {
+    it('should return empty array for getLogs', async () => {
+      const logs = await fileLogger.getLogs();
+      expect(logs.length).toBeGreaterThan(0);
+    });
+
+    it('should return empty array for getLogsByRunId', async () => {
+      const logger = createLogger({
+        name: 'test-logger',
+        level: LogLevel.INFO,
+        transports: {
+          file: fileLogger,
+        },
+      });
+
+      let logs = await fileLogger.getLogsByRunId({ runId: 'test-run-id' });
+      expect(logs.length).toBe(0);
+
+      logger.info('test info message', {
+        runId: 'test-run-id',
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      logs = await fileLogger.getLogsByRunId({ runId: 'test-run-id' });
+      expect(logs.length).toBe(1);
+    });
+  });
+});

package/src/file/index.ts

@@ -0,0 +1,73 @@
+import type { WriteStream } from 'fs';
+import { createWriteStream, existsSync, readFileSync } from 'fs';
+import { LoggerTransport } from '@mastra/core/logger';
+import type { BaseLogMessage } from '@mastra/core/logger';
+
+export class FileTransport extends LoggerTransport {
+  path: string;
+  fileStream: WriteStream;
+  constructor({ path }: { path: string }) {
+    super({ objectMode: true });
+    this.path = path;
+
+    if (!existsSync(this.path)) {
+      console.log(this.path);
+      throw new Error('File path does not exist');
+    }
+
+    this.fileStream = createWriteStream(this.path, { flags: 'a' });
+  }
+
+  _transform(chunk: any, _encoding: string, callback: (error: Error | null, chunk: any) => void) {
+    try {
+      this.fileStream.write(chunk);
+    } catch (error) {
+      console.error('Error parsing log entry:', error);
+    }
+    callback(null, chunk);
+  }
+
+  _flush(callback: Function) {
+    // End the file stream when transform stream ends
+    this.fileStream.end(() => {
+      callback();
+    });
+  }
+
+  _write(chunk: any, encoding?: string, callback?: (error?: Error | null) => void): boolean {
+    if (typeof callback === 'function') {
+      this._transform(chunk, encoding || 'utf8', callback);
+      return true;
+    }
+
+    this._transform(chunk, encoding || 'utf8', (error: Error | null) => {
+      if (error) console.error('Transform error in write:', error);
+    });
+    return true;
+  }
+
+  // Clean up resources
+  _destroy(error: Error, callback: Function) {
+    if (this.fileStream) {
+      this.fileStream.destroy(error);
+    }
+    callback(error);
+  }
+
+  async getLogs(): Promise<BaseLogMessage[]> {
+    return readFileSync(this.path, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map(log => JSON.parse(log));
+  }
+
+  async getLogsByRunId({ runId }: { runId: string }): Promise<BaseLogMessage[]> {
+    try {
+      const allLogs = await this.getLogs();
+      return (allLogs.filter(log => log?.runId === runId) || []) as BaseLogMessage[];
+    } catch (error) {
+      console.error('Error getting logs by runId from Upstash:', error);
+      return [] as BaseLogMessage[];
+    }
+  }
+}

package/src/upstash/index.test.ts

@@ -0,0 +1,184 @@
+import { createLogger, LogLevel } from '@mastra/core/logger';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+import { UpstashTransport } from './index.js';
+
+describe('UpstashTransport', () => {
+  const defaultOptions = {
+    upstashUrl: 'https://test-url.upstash.io',
+    upstashToken: 'test-token',
+    listName: 'test-logs',
+    maxListLength: 1000,
+    batchSize: 10,
+    flushInterval: 1000,
+  };
+
+  let transport: UpstashTransport;
+  let fetchMock: any;
+
+  beforeEach(() => {
+    fetchMock = vi.fn(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ result: 'success' }),
+      }),
+    );
+    global.fetch = fetchMock;
+
+    vi.useFakeTimers();
+    transport = new UpstashTransport(defaultOptions);
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.clearAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('should initialize with correct options', () => {
+    expect(transport.upstashUrl).toBe(defaultOptions.upstashUrl);
+    expect(transport.upstashToken).toBe(defaultOptions.upstashToken);
+    expect(transport.listName).toBe(defaultOptions.listName);
+    expect(transport.logBuffer).toEqual([]);
+  });
+
+  it('should work with createLogger', async () => {
+    const logger = createLogger({
+      name: 'test-logger',
+      level: LogLevel.INFO,
+      transports: {
+        upstash: transport,
+      },
+    });
+
+    const testMessage = 'test info message';
+    logger.info(testMessage);
+
+    // Trigger flush
+    await transport._flush();
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      defaultOptions.upstashUrl,
+      expect.objectContaining({
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${defaultOptions.upstashToken}`,
+          'Content-Type': 'application/json',
+        },
+        body: expect.stringContaining(testMessage),
+      }),
+    );
+  });
+
+  it('should handle multiple log messages', async () => {
+    const logger = createLogger({
+      name: 'test-logger',
+      level: LogLevel.INFO,
+      transports: {
+        upstash: transport,
+      },
+    });
+
+    const messages = ['message1', 'message2', 'message3'];
+    messages.forEach(msg => logger.info(msg));
+
+    // Trigger flush
+    await transport._flush();
+
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+    messages.forEach(msg => {
+      expect(body.pipeline[0].some((cmd: string) => cmd.includes(msg))).toBe(true);
+    });
+  });
+
+  it('should properly clean up resources on destroy', () => {
+    const clearIntervalSpy = vi.spyOn(global, 'clearInterval');
+    const flushSpy = vi.spyOn(transport, '_flush').mockImplementation(() => Promise.resolve());
+
+    transport._destroy(new Error('test'), () => {
+      expect(clearIntervalSpy).toHaveBeenCalled();
+      if (transport.logBuffer.length > 0) {
+        expect(flushSpy).toHaveBeenCalled();
+      }
+    });
+  });
+
+  it('should handle errors in _transform', () => {
+    const callback = vi.fn();
+
+    transport._transform('invalid json', 'utf8', callback);
+
+    expect(callback).toHaveBeenCalledWith(expect.any(Error));
+  });
+
+  it('should automatically flush on interval', async () => {
+    const logger = createLogger({
+      name: 'test-logger',
+      level: LogLevel.INFO,
+      transports: {
+        upstash: transport,
+      },
+    });
+
+    logger.info('test message');
+
+    // Advance timer by flush interval
+    vi.advanceTimersByTime(defaultOptions.flushInterval);
+    await Promise.resolve();
+
+    expect(fetchMock).toHaveBeenCalled();
+  });
+
+  describe('error handling', () => {
+    it('should handle Upstash API errors', async () => {
+      fetchMock.mockImplementationOnce(() =>
+        Promise.resolve({
+          ok: false,
+          statusText: 'Test Error',
+        }),
+      );
+
+      const logger = createLogger({
+        name: 'test-logger',
+        level: LogLevel.INFO,
+        transports: {
+          upstash: transport,
+        },
+      });
+
+      logger.info('test message');
+
+      await expect(transport._flush()).rejects.toThrow('Failed to execute Upstash command: Test Error');
+      expect(transport.logBuffer.length).toBeGreaterThan(0);
+    });
+
+    it('should handle network errors', async () => {
+      fetchMock.mockImplementationOnce(() => Promise.reject(new Error('Network error')));
+
+      const logger = createLogger({
+        name: 'test-logger',
+        level: LogLevel.INFO,
+        transports: {
+          upstash: transport,
+        },
+      });
+
+      logger.info('test message');
+
+      await expect(transport._flush()).rejects.toThrow('Network error');
+      expect(transport.logBuffer.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getLogs and getLogsByRunId', () => {
+    it('should return empty array for getLogs', async () => {
+      const logs = await transport.getLogs();
+      expect(logs).toEqual([]);
+    });
+
+    it('should return empty array for getLogsByRunId', async () => {
+      const logs = await transport.getLogsByRunId({ runId: 'test-run-id' });
+      expect(logs).toEqual([]);
+    });
+  });
+});

package/src/upstash/index.ts

@@ -0,0 +1,176 @@
+import { LoggerTransport } from '@mastra/core/logger';
+import type { BaseLogMessage } from '@mastra/core/logger';
+
+export class UpstashTransport extends LoggerTransport {
+  upstashUrl: string;
+  upstashToken: string;
+  listName: string;
+  maxListLength: number;
+  batchSize: number;
+  flushInterval: number;
+  logBuffer: any[];
+  lastFlush: number;
+  flushIntervalId: NodeJS.Timeout;
+
+  constructor(opts: {
+    listName?: string;
+    maxListLength?: number;
+    batchSize?: number;
+    upstashUrl: string;
+    flushInterval?: number;
+    upstashToken: string;
+  }) {
+    super({ objectMode: true });
+
+    if (!opts.upstashUrl || !opts.upstashToken) {
+      throw new Error('Upstash URL and token are required');
+    }
+
+    this.upstashUrl = opts.upstashUrl;
+    this.upstashToken = opts.upstashToken;
+    this.listName = opts.listName || 'application-logs';
+    this.maxListLength = opts.maxListLength || 10000;
+    this.batchSize = opts.batchSize || 100;
+    this.flushInterval = opts.flushInterval || 10000;
+
+    this.logBuffer = [];
+    this.lastFlush = Date.now();
+
+    // Start flush interval
+    this.flushIntervalId = setInterval(() => {
+      this._flush().catch(err => {
+        console.error('Error flushing logs to Upstash:', err);
+      });
+    }, this.flushInterval);
+  }
+
+  private async executeUpstashCommand(command: any[]): Promise<any> {
+    const response = await fetch(`${this.upstashUrl}/pipeline`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.upstashToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify([command]),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to execute Upstash command: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async _flush() {
+    if (this.logBuffer.length === 0) {
+      return;
+    }
+
+    const now = Date.now();
+    const logs = this.logBuffer.splice(0, this.batchSize);
+
+    try {
+      // Prepare the Upstash Redis command
+      const command = ['LPUSH', this.listName, ...logs.map(log => JSON.stringify(log))];
+
+      // Trim the list if it exceeds maxListLength
+      if (this.maxListLength > 0) {
+        command.push('LTRIM', this.listName, 0 as any, (this.maxListLength - 1) as any);
+      }
+
+      // Send logs to Upstash Redis
+      await this.executeUpstashCommand(command);
+      this.lastFlush = now;
+    } catch (error) {
+      // On error, put logs back in the buffer
+      this.logBuffer.unshift(...logs);
+      throw error;
+    }
+  }
+
+  _write(chunk: any, encoding?: string, callback?: (error?: Error | null) => void): boolean {
+    if (typeof callback === 'function') {
+      this._transform(chunk, encoding || 'utf8', callback);
+      return true;
+    }
+
+    this._transform(chunk, encoding || 'utf8', (error: Error | null) => {
+      if (error) console.error('Transform error in write:', error);
+    });
+    return true;
+  }
+
+  _transform(chunk: string, _enc: string, cb: Function) {
+    try {
+      // Parse the log line if it's a string
+      const log = typeof chunk === 'string' ? JSON.parse(chunk) : chunk;
+
+      // Add timestamp if not present
+      if (!log.time) {
+        log.time = Date.now();
+      }
+
+      // Add to buffer
+      this.logBuffer.push(log);
+
+      // Flush if buffer reaches batch size
+      if (this.logBuffer.length >= this.batchSize) {
+        this._flush().catch(err => {
+          console.error('Error flushing logs to Upstash:', err);
+        });
+      }
+
+      // Pass through the log
+      cb(null, chunk);
+    } catch (error) {
+      cb(error);
+    }
+  }
+
+  _destroy(err: Error, cb: Function) {
+    clearInterval(this.flushIntervalId);
+
+    // Final flush
+    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(): Promise<BaseLogMessage[]> {
+    try {
+      // Get all logs from the list
+      const command = ['LRANGE', this.listName, 0, -1];
+      const response = await this.executeUpstashCommand(command);
+
+      // Parse the logs from JSON strings back to objects
+      return response?.[0]?.result.map((log: string) => {
+        try {
+          return JSON.parse(log);
+        } catch {
+          return '';
+        }
+      }) as BaseLogMessage[];
+    } catch (error) {
+      console.error('Error getting logs from Upstash:', error);
+      return [];
+    }
+  }
+
+  async getLogsByRunId({ runId }: { runId: string }): Promise<BaseLogMessage[]> {
+    try {
+      const allLogs = await this.getLogs();
+      const logs = (allLogs.filter((log: any) => log.runId === runId) || []) as BaseLogMessage[];
+      return logs;
+    } catch (error) {
+      console.error('Error getting logs by runId from Upstash:', error);
+      return [] as BaseLogMessage[];
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.node.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['src/**/*.test.ts'],
+  },
+});