@mastra/loggers 0.1.6-alpha.0 → 0.1.6-alpha.3

package/.turbo/turbo-build.log

@@ -1,19 +1,25 @@
 
-> @mastra/loggers@0.1.6-alpha.0 build /home/runner/work/mastra/mastra/packages/loggers
-> tsup src/file/index.ts src/upstash/index.ts --format esm --experimental-dts --clean --treeshake
+> @mastra/loggers@0.1.6-alpha.3 build /home/runner/work/mastra/mastra/packages/loggers
+> tsup src/file/index.ts src/upstash/index.ts --format esm,cjs --experimental-dts --clean --treeshake
 
 CLI Building entry: src/file/index.ts, src/upstash/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.3.6
 TSC Build start
-TSC ⚡️ Build success in 5437ms
+TSC ⚡️ Build success in 5816ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.7.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/loggers/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 5926ms
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: /home/runner/work/mastra/mastra/packages/loggers/dist/_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 8917ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/upstash/index.js 3.71 KB
+CJS Build start
 ESM dist/file/index.js    1.64 KB
-ESM ⚡️ Build success in 545ms
+ESM dist/upstash/index.js 3.71 KB
+ESM ⚡️ Build success in 537ms
+CJS dist/file/index.cjs    1.64 KB
+CJS dist/upstash/index.cjs 3.74 KB
+CJS ⚡️ Build success in 536ms

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @mastra/loggers
 
+## 0.1.6-alpha.3
+
+### Patch Changes
+
+- bb4f447: Add support for commonjs
+- Updated dependencies [0fd78ac]
+- Updated dependencies [0d25b75]
+- Updated dependencies [fd14a3f]
+- Updated dependencies [3f369a2]
+- Updated dependencies [4d4e1e1]
+- Updated dependencies [bb4f447]
+  - @mastra/core@0.4.3-alpha.3
+
+## 0.1.6-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [2512a93]
+- Updated dependencies [e62de74]
+  - @mastra/core@0.4.3-alpha.2
+
+## 0.1.6-alpha.1
+
+### Patch Changes
+
+- Updated dependencies [0d185b1]
+- Updated dependencies [ed55f1d]
+- Updated dependencies [8d13b14]
+- Updated dependencies [3ee4831]
+- Updated dependencies [108793c]
+- Updated dependencies [5f28f44]
+  - @mastra/core@0.4.3-alpha.1
+
 ## 0.1.6-alpha.0
 
 ### Patch Changes

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

@@ -0,0 +1,50 @@
+import type { BaseLogMessage } from '@mastra/core/logger';
+import { LoggerTransport } from '@mastra/core/logger';
+import type { WriteStream } from 'fs';
+
+export declare class FileTransport extends LoggerTransport {
+    path: string;
+    fileStream: WriteStream;
+    constructor({ path }: {
+        path: string;
+    });
+    _transform(chunk: any, _encoding: string, callback: (error: Error | null, chunk: any) => void): void;
+    _flush(callback: Function): void;
+    _write(chunk: any, encoding?: string, callback?: (error?: Error | null) => void): boolean;
+    _destroy(error: Error, callback: Function): void;
+    getLogs(): Promise<BaseLogMessage[]>;
+    getLogsByRunId({ runId }: {
+        runId: string;
+    }): Promise<BaseLogMessage[]>;
+}
+
+export declare 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;
+    });
+    private executeUpstashCommand;
+    _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(): Promise<BaseLogMessage[]>;
+    getLogsByRunId({ runId }: {
+        runId: string;
+    }): Promise<BaseLogMessage[]>;
+}
+
+export { }

package/dist/file/index.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var fs = require('fs');
+var logger = require('@mastra/core/logger');
+
+// src/file/index.ts
+var FileTransport = class extends logger.LoggerTransport {
+  path;
+  fileStream;
+  constructor({ path }) {
+    super({ objectMode: true });
+    this.path = path;
+    if (!fs.existsSync(this.path)) {
+      console.log(this.path);
+      throw new Error("File path does not exist");
+    }
+    this.fileStream = fs.createWriteStream(this.path, { flags: "a" });
+  }
+  _transform(chunk, _encoding, callback) {
+    try {
+      this.fileStream.write(chunk);
+    } catch (error) {
+      console.error("Error parsing log entry:", error);
+    }
+    callback(null, chunk);
+  }
+  _flush(callback) {
+    this.fileStream.end(() => {
+      callback();
+    });
+  }
+  _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;
+  }
+  // Clean up resources
+  _destroy(error, callback) {
+    if (this.fileStream) {
+      this.fileStream.destroy(error);
+    }
+    callback(error);
+  }
+  async getLogs() {
+    return fs.readFileSync(this.path, "utf8").split("\n").filter(Boolean).map((log) => JSON.parse(log));
+  }
+  async getLogsByRunId({ runId }) {
+    try {
+      const allLogs = await this.getLogs();
+      return allLogs.filter((log) => log?.runId === runId) || [];
+    } catch (error) {
+      console.error("Error getting logs by runId from Upstash:", error);
+      return [];
+    }
+  }
+};
+
+exports.FileTransport = FileTransport;

package/dist/file/index.d.cts

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

package/dist/upstash/index.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+var logger = require('@mastra/core/logger');
+
+// src/upstash/index.ts
+var UpstashTransport = class extends logger.LoggerTransport {
+  upstashUrl;
+  upstashToken;
+  listName;
+  maxListLength;
+  batchSize;
+  flushInterval;
+  logBuffer;
+  lastFlush;
+  flushIntervalId;
+  constructor(opts) {
+    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 || 1e4;
+    this.batchSize = opts.batchSize || 100;
+    this.flushInterval = opts.flushInterval || 1e4;
+    this.logBuffer = [];
+    this.lastFlush = Date.now();
+    this.flushIntervalId = setInterval(() => {
+      this._flush().catch((err) => {
+        console.error("Error flushing logs to Upstash:", err);
+      });
+    }, this.flushInterval);
+  }
+  async executeUpstashCommand(command) {
+    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 {
+      const command = ["LPUSH", this.listName, ...logs.map((log) => JSON.stringify(log))];
+      if (this.maxListLength > 0) {
+        command.push("LTRIM", this.listName, 0, this.maxListLength - 1);
+      }
+      await this.executeUpstashCommand(command);
+      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 Upstash:", 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() {
+    try {
+      const command = ["LRANGE", this.listName, 0, -1];
+      const response = await this.executeUpstashCommand(command);
+      return response?.[0]?.result.map((log) => {
+        try {
+          return JSON.parse(log);
+        } catch {
+          return "";
+        }
+      });
+    } catch (error) {
+      console.error("Error getting logs from Upstash:", error);
+      return [];
+    }
+  }
+  async getLogsByRunId({ runId }) {
+    try {
+      const allLogs = await this.getLogs();
+      const logs = allLogs.filter((log) => log.runId === runId) || [];
+      return logs;
+    } catch (error) {
+      console.error("Error getting logs by runId from Upstash:", error);
+      return [];
+    }
+  }
+};
+
+exports.UpstashTransport = UpstashTransport;

package/dist/upstash/index.d.cts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/loggers",
-  "version": "0.1.6-alpha.0",
+  "version": "0.1.6-alpha.3",
   "description": "",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -10,18 +10,30 @@
       "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"
@@ -30,7 +42,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@mastra/core": "^0.4.3-alpha.0"
+    "@mastra/core": "^0.4.3-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
@@ -42,7 +54,7 @@
     "@internal/lint": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/file/index.ts src/upstash/index.ts --format esm --experimental-dts --clean --treeshake",
+    "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 ."