imean-service-engine 1.1.0 → 1.2.0

package/README.md

@@ -1,9 +1,7 @@
-# Microservice Framework for Deno
+# Microservice Framework
 
 一个轻量级的 TypeScript 微服务框架。提供了类型安全、自动客户端生成、请求重试等特性。
 
-[![JSR](https://jsr.io/badges/@imean/service-engine)](https://jsr.io/@imean/service-engine)
-
 ## 特性
 
 - 📝 完全的 TypeScript 支持
@@ -14,7 +12,6 @@
 - 🌟 优雅的装饰器 API
 - 🚦 优雅停机支持
 - 📡 生成基于 fetch 的客户端代码,可以在 Deno 、Node.js、Bun 以及浏览器中使用
-- 🌟 服务间调用可以利用 Deno 的分布式模块引入快速集成生成的客户端
 - 🌟 支持 Stream 流传输，客户端使用 AsyncIterator 迭代
 - 🌟 服务引擎支持通过 WebSocket 进行实时通信，相比 HTTP 请求具有以下优势：
   - 保持长连接，减少连接建立的开销
@@ -30,7 +27,7 @@
 ## 安装
 
 ```typescript
-import { Action, Microservice, Module } from "jsr:@imean/microservice";
+import { Action, Microservice, Module } from "imean-service-engine";
 ```
 
 ## 快速开始
@@ -126,7 +123,7 @@ TypeScript 客户端代码。
 
 ```typescript
 const client = new MicroserviceClient({
-  baseUrl: "http://localhost:3000/client.ts?cache=v1",
+  baseUrl: "http://localhost:3000",
 });
 // 创建用户
 const user = await client.users.createUser("张三", 25);
@@ -230,7 +227,7 @@ interface ClientOptions {
 
 ```typescript
 // main.ts
-import { startCheck } from "jsr:@imean/microservice";
+import { startCheck } from "imean-service-engine";
 
 // 数据库连接检查
 async function checkDatabase() {
@@ -326,17 +323,17 @@ your-service/
 // config/index.ts
 export const config = {
   database: {
-    host: Deno.env.get("DB_HOST") || "localhost",
-    port: parseInt(Deno.env.get("DB_PORT") || "5432"),
+    host: process.env.DB_HOST || "localhost",
+    port: parseInt(process.env.DB_PORT || "5432"),
     // ...
   },
   redis: {
-    url: Deno.env.get("REDIS_URL") || "redis://localhost:6379",
+    url: process.env.REDIS_URL || "redis://localhost:6379",
     // ...
   },
   service: {
-    port: parseInt(Deno.env.get("PORT") || "3000"),
-    prefix: Deno.env.get("API_PREFIX") || "/api",
+    port: parseInt(process.env.PORT || "3000"),
+    prefix: process.env.API_PREFIX || "/api",
   },
 };
 
@@ -550,7 +547,7 @@ const client = new MicroserviceClient({
 
 ### Node.js 环境使用 WebSocket
 
-在 Node.js 环境下，可以使用 `isomorphic-ws` 包来提供 WebSocket 实现：
+最新Node.js已经提供了 WebSocket 实现，可以直接使用。如果在较低 Node.js 环境下，可以使用 `isomorphic-ws` 包来提供 WebSocket 实现：
 
 ```typescript
 import WebSocket from "isomorphic-ws";

package/dist/mod.cjs

@@ -7,10 +7,9 @@ var etcd3 = require('etcd3');
 var fs = require('fs-extra');
 var hono = require('hono');
 var lruCache = require('lru-cache');
+var api = require('@opentelemetry/api');
 var winston = require('winston');
 var prettier = require('prettier');
-var api = require('@opentelemetry/api');
-var apiLogs = require('@opentelemetry/api-logs');
 var crypto2 = require('crypto');
 var zlib = require('zlib');
 var nodeWs = require('@hono/node-ws');
@@ -110,6 +109,7 @@ var logger = winston__default.default.createLogger({
 var logger_default = logger;
 
 // decorators/schedule.ts
+var tracer = api.trace.getTracer("scheduler");
 var SCHEDULE_METADATA = Symbol("schedule:metadata");
 function Schedule(options) {
   return function(_originalMethod, context) {
@@ -162,20 +162,44 @@ var Scheduler = class {
     });
     campaign.on("elected", () => {
       this.isLeader.set(serviceId, true);
-      this.startTimer(serviceId, metadata, method);
+      this.startTimer(serviceId, metadata, moduleName, method);
       logger_default.info(`become leader for ${moduleName}.${methodName}`);
     });
   }
   /**
    * 启动定时器
    */
-  startTimer(serviceId, metadata, method) {
+  startTimer(serviceId, metadata, moduleName, method) {
     this.stopTimer(serviceId);
+    const wrappedMethod = async () => {
+      tracer.startActiveSpan(
+        `ScheduleTask ${moduleName}.${metadata.name}`,
+        { root: true },
+        async (span) => {
+          span.setAttribute("serviceId", serviceId);
+          span.setAttribute("methodName", metadata.name);
+          span.setAttribute("moduleName", moduleName);
+          span.setAttribute("interval", metadata.interval);
+          span.setAttribute("mode", metadata.mode);
+          try {
+            await method();
+          } catch (error) {
+            span.setStatus({
+              code: api.SpanStatusCode.ERROR,
+              message: error.message
+            });
+          } finally {
+            span.setStatus({ code: api.SpanStatusCode.OK });
+            span.end();
+          }
+        }
+      );
+    };
     if (metadata.mode === "FIXED_DELAY" /* FIXED_DELAY */) {
       const runTask = async () => {
         if (!this.isLeader.get(serviceId)) return;
         try {
-          await method();
+          await wrappedMethod();
         } finally {
           this.timers.set(serviceId, setTimeout(runTask, metadata.interval));
         }
@@ -186,7 +210,7 @@ var Scheduler = class {
         serviceId,
         setInterval(async () => {
           if (!this.isLeader.get(serviceId)) return;
-          await method();
+          await wrappedMethod();
         }, metadata.interval)
       );
     }
@@ -389,8 +413,7 @@ var brotli = {
 };
 
 // core/handler.ts
-var tracer = api.trace.getTracer("action-handler");
-var logger2 = apiLogs.logs.getLogger("action-handler");
+var tracer2 = api.trace.getTracer("action-handler");
 var ActionHandler = class {
   constructor(moduleInstance, actionName, metadata, microservice, moduleName) {
     this.moduleInstance = moduleInstance;
@@ -400,46 +423,59 @@ var ActionHandler = class {
     this.moduleName = moduleName;
   }
   async handle(req) {
-    const span = tracer.startSpan("handle");
-    span.addEvent("logs");
-    logger2.emit({
-      attributes: { module: this.moduleName, action: this.actionName }
-    });
-    const startTime = Date.now();
-    let args;
-    if (typeof req === "string") {
-      try {
-        args = Object.values(ejson3__default.default.parse(req));
-      } catch (error) {
-        throw new Error(`Invalid request body: ${error.message}`);
+    return await tracer2.startActiveSpan(
+      `handle ${this.moduleName}.${this.actionName}`,
+      async (span) => {
+        span.setAttribute("module", this.moduleName);
+        span.setAttribute("action", this.actionName);
+        try {
+          return await this._handle(req);
+        } finally {
+          span.end();
+        }
       }
-    } else {
-      args = req;
-    }
-    if (this.metadata.params) {
-      args = args.map((arg, index) => {
+    );
+  }
+  async _validate(req) {
+    const span = tracer2.startSpan("validate");
+    try {
+      let args;
+      if (typeof req === "string") {
         try {
-          return this.metadata.params[index].parse(arg);
+          args = Object.values(ejson3__default.default.parse(req));
         } catch (error) {
-          throw new Error(
-            `Invalid argument ${index}: ${error.message}`
-          );
+          throw new Error(`Invalid request body: ${error.message}`);
         }
-      });
+      } else {
+        args = req;
+      }
+      if (this.metadata.params) {
+        args = args.map((arg, index) => {
+          try {
+            return this.metadata.params[index].parse(arg);
+          } catch (error) {
+            throw new Error(
+              `Invalid argument ${index}: ${error.message}`
+            );
+          }
+        });
+      }
+      const requestHash = hashText(ejson3__default.default.stringify(args));
+      span.setAttribute("requestHash", requestHash);
+      return { args, requestHash };
+    } finally {
+      span.end();
     }
-    const requestHash = hashText(ejson3__default.default.stringify(args));
+  }
+  async _handle(req) {
+    const span = api.trace.getActiveSpan();
+    const { args, requestHash } = await this._validate(req);
     if (!this.metadata.stream && this.metadata.cache && !this.microservice.options.disableCache) {
       const cacheKey = `${this.moduleName}.${this.actionName}.${requestHash}`;
       const cached = await this.microservice.cache.get(cacheKey);
       const now = Date.now();
       if (cached !== null && (!this.metadata.ttl || cached?.expireAt > now)) {
-        this.microservice.updateMethodStats(
-          this.moduleName,
-          this.actionName,
-          0,
-          true,
-          true
-        );
+        span?.setAttribute("cacheHit", true);
         return cached.data;
       }
     }
@@ -449,11 +485,11 @@ var ActionHandler = class {
         args
       );
       if (this.metadata.stream) {
+        span?.setAttribute("stream", true);
         if (!isAsyncIterable(result)) {
           throw new Error("Stream action must return AsyncIterator");
         }
         let count = 0;
-        const self = this;
         return {
           [Symbol.asyncIterator]() {
             const iterator = result[Symbol.asyncIterator]();
@@ -461,24 +497,22 @@ var ActionHandler = class {
               async next() {
                 try {
                   const { value, done } = await iterator.next();
+                  span?.addEvent("stream.next");
                   if (!done) count++;
                   if (done) {
-                    const responseTime = Date.now() - startTime;
-                    self.microservice.updateMethodStats(
-                      self.moduleName,
-                      self.actionName,
-                      responseTime / count,
-                      true
-                    );
+                    span?.setAttribute("streamCount", count);
+                    span?.addEvent("stream.end");
+                    span?.end();
                   }
                   return { value, done };
                 } catch (error) {
-                  self.microservice.updateMethodStats(
-                    self.moduleName,
-                    self.actionName,
-                    0,
-                    false
-                  );
+                  span?.addEvent("stream.error", { error: error.message });
+                  span?.recordException(error);
+                  span?.setStatus({
+                    code: api.SpanStatusCode.ERROR,
+                    message: error.message
+                  });
+                  span?.end();
                   throw error;
                 }
               }
@@ -506,36 +540,17 @@ var ActionHandler = class {
           { ttl: this.metadata.ttl }
         );
       }
-      this.microservice.updateMethodStats(
-        this.moduleName,
-        this.actionName,
-        0,
-        true
-      );
+      span?.setStatus({ code: api.SpanStatusCode.OK, message: "success" });
+      span?.end();
       return parsedResult;
     } catch (error) {
       if (this.metadata.printError !== false && this.microservice.options.printError !== false) {
         console.error(`Error in ${this.moduleName}.${this.actionName}:`, error);
       }
-      if (this.microservice.options.events?.onError) {
-        this.microservice.options.events.onError({
-          requestHash,
-          service: {
-            id: this.microservice.serviceId,
-            name: this.microservice.options.name,
-            version: this.microservice.options.version,
-            env: this.microservice.options.env
-          },
-          module: this.moduleName,
-          action: this.actionName,
-          params: args,
-          time: Date.now(),
-          error: error.message
-        });
-      }
+      span?.recordException(error);
+      span?.setStatus({ code: api.SpanStatusCode.ERROR, message: error.message });
+      span?.end();
       throw error;
-    } finally {
-      span.end();
     }
   }
 };

package/dist/mod.d.cts

@@ -149,6 +149,8 @@ declare class ActionHandler {
     private moduleName;
     constructor(moduleInstance: any, actionName: string, metadata: ActionMetadata, microservice: Microservice, moduleName: string);
     handle(req: string | any[]): Promise<any>;
+    private _validate;
+    private _handle;
 }
 
 declare const ServiceContext: {

package/dist/mod.d.ts

@@ -149,6 +149,8 @@ declare class ActionHandler {
     private moduleName;
     constructor(moduleInstance: any, actionName: string, metadata: ActionMetadata, microservice: Microservice, moduleName: string);
     handle(req: string | any[]): Promise<any>;
+    private _validate;
+    private _handle;
 }
 
 declare const ServiceContext: {

package/dist/mod.js

@@ -6,10 +6,9 @@ import { Etcd3 } from 'etcd3';
 import fs from 'fs-extra';
 import { Hono } from 'hono';
 import { LRUCache } from 'lru-cache';
+import { trace, SpanStatusCode } from '@opentelemetry/api';
 import winston, { format } from 'winston';
 import prettier from 'prettier';
-import { trace } from '@opentelemetry/api';
-import { logs } from '@opentelemetry/api-logs';
 import crypto2 from 'node:crypto';
 import { brotliDecompress } from 'node:zlib';
 import { brotliCompress, constants } from 'zlib';
@@ -101,6 +100,7 @@ var logger = winston.createLogger({
 var logger_default = logger;
 
 // decorators/schedule.ts
+var tracer = trace.getTracer("scheduler");
 var SCHEDULE_METADATA = Symbol("schedule:metadata");
 function Schedule(options) {
   return function(_originalMethod, context) {
@@ -153,20 +153,44 @@ var Scheduler = class {
     });
     campaign.on("elected", () => {
       this.isLeader.set(serviceId, true);
-      this.startTimer(serviceId, metadata, method);
+      this.startTimer(serviceId, metadata, moduleName, method);
       logger_default.info(`become leader for ${moduleName}.${methodName}`);
     });
   }
   /**
    * 启动定时器
    */
-  startTimer(serviceId, metadata, method) {
+  startTimer(serviceId, metadata, moduleName, method) {
     this.stopTimer(serviceId);
+    const wrappedMethod = async () => {
+      tracer.startActiveSpan(
+        `ScheduleTask ${moduleName}.${metadata.name}`,
+        { root: true },
+        async (span) => {
+          span.setAttribute("serviceId", serviceId);
+          span.setAttribute("methodName", metadata.name);
+          span.setAttribute("moduleName", moduleName);
+          span.setAttribute("interval", metadata.interval);
+          span.setAttribute("mode", metadata.mode);
+          try {
+            await method();
+          } catch (error) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: error.message
+            });
+          } finally {
+            span.setStatus({ code: SpanStatusCode.OK });
+            span.end();
+          }
+        }
+      );
+    };
     if (metadata.mode === "FIXED_DELAY" /* FIXED_DELAY */) {
       const runTask = async () => {
         if (!this.isLeader.get(serviceId)) return;
         try {
-          await method();
+          await wrappedMethod();
         } finally {
           this.timers.set(serviceId, setTimeout(runTask, metadata.interval));
         }
@@ -177,7 +201,7 @@ var Scheduler = class {
         serviceId,
         setInterval(async () => {
           if (!this.isLeader.get(serviceId)) return;
-          await method();
+          await wrappedMethod();
         }, metadata.interval)
       );
     }
@@ -380,8 +404,7 @@ var brotli = {
 };
 
 // core/handler.ts
-var tracer = trace.getTracer("action-handler");
-var logger2 = logs.getLogger("action-handler");
+var tracer2 = trace.getTracer("action-handler");
 var ActionHandler = class {
   constructor(moduleInstance, actionName, metadata, microservice, moduleName) {
     this.moduleInstance = moduleInstance;
@@ -391,46 +414,59 @@ var ActionHandler = class {
     this.moduleName = moduleName;
   }
   async handle(req) {
-    const span = tracer.startSpan("handle");
-    span.addEvent("logs");
-    logger2.emit({
-      attributes: { module: this.moduleName, action: this.actionName }
-    });
-    const startTime = Date.now();
-    let args;
-    if (typeof req === "string") {
-      try {
-        args = Object.values(ejson3.parse(req));
-      } catch (error) {
-        throw new Error(`Invalid request body: ${error.message}`);
+    return await tracer2.startActiveSpan(
+      `handle ${this.moduleName}.${this.actionName}`,
+      async (span) => {
+        span.setAttribute("module", this.moduleName);
+        span.setAttribute("action", this.actionName);
+        try {
+          return await this._handle(req);
+        } finally {
+          span.end();
+        }
       }
-    } else {
-      args = req;
-    }
-    if (this.metadata.params) {
-      args = args.map((arg, index) => {
+    );
+  }
+  async _validate(req) {
+    const span = tracer2.startSpan("validate");
+    try {
+      let args;
+      if (typeof req === "string") {
         try {
-          return this.metadata.params[index].parse(arg);
+          args = Object.values(ejson3.parse(req));
         } catch (error) {
-          throw new Error(
-            `Invalid argument ${index}: ${error.message}`
-          );
+          throw new Error(`Invalid request body: ${error.message}`);
         }
-      });
+      } else {
+        args = req;
+      }
+      if (this.metadata.params) {
+        args = args.map((arg, index) => {
+          try {
+            return this.metadata.params[index].parse(arg);
+          } catch (error) {
+            throw new Error(
+              `Invalid argument ${index}: ${error.message}`
+            );
+          }
+        });
+      }
+      const requestHash = hashText(ejson3.stringify(args));
+      span.setAttribute("requestHash", requestHash);
+      return { args, requestHash };
+    } finally {
+      span.end();
     }
-    const requestHash = hashText(ejson3.stringify(args));
+  }
+  async _handle(req) {
+    const span = trace.getActiveSpan();
+    const { args, requestHash } = await this._validate(req);
     if (!this.metadata.stream && this.metadata.cache && !this.microservice.options.disableCache) {
       const cacheKey = `${this.moduleName}.${this.actionName}.${requestHash}`;
       const cached = await this.microservice.cache.get(cacheKey);
       const now = Date.now();
       if (cached !== null && (!this.metadata.ttl || cached?.expireAt > now)) {
-        this.microservice.updateMethodStats(
-          this.moduleName,
-          this.actionName,
-          0,
-          true,
-          true
-        );
+        span?.setAttribute("cacheHit", true);
         return cached.data;
       }
     }
@@ -440,11 +476,11 @@ var ActionHandler = class {
         args
       );
       if (this.metadata.stream) {
+        span?.setAttribute("stream", true);
         if (!isAsyncIterable(result)) {
           throw new Error("Stream action must return AsyncIterator");
         }
         let count = 0;
-        const self = this;
         return {
           [Symbol.asyncIterator]() {
             const iterator = result[Symbol.asyncIterator]();
@@ -452,24 +488,22 @@ var ActionHandler = class {
               async next() {
                 try {
                   const { value, done } = await iterator.next();
+                  span?.addEvent("stream.next");
                   if (!done) count++;
                   if (done) {
-                    const responseTime = Date.now() - startTime;
-                    self.microservice.updateMethodStats(
-                      self.moduleName,
-                      self.actionName,
-                      responseTime / count,
-                      true
-                    );
+                    span?.setAttribute("streamCount", count);
+                    span?.addEvent("stream.end");
+                    span?.end();
                   }
                   return { value, done };
                 } catch (error) {
-                  self.microservice.updateMethodStats(
-                    self.moduleName,
-                    self.actionName,
-                    0,
-                    false
-                  );
+                  span?.addEvent("stream.error", { error: error.message });
+                  span?.recordException(error);
+                  span?.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error.message
+                  });
+                  span?.end();
                   throw error;
                 }
               }
@@ -497,36 +531,17 @@ var ActionHandler = class {
           { ttl: this.metadata.ttl }
         );
       }
-      this.microservice.updateMethodStats(
-        this.moduleName,
-        this.actionName,
-        0,
-        true
-      );
+      span?.setStatus({ code: SpanStatusCode.OK, message: "success" });
+      span?.end();
       return parsedResult;
     } catch (error) {
       if (this.metadata.printError !== false && this.microservice.options.printError !== false) {
         console.error(`Error in ${this.moduleName}.${this.actionName}:`, error);
       }
-      if (this.microservice.options.events?.onError) {
-        this.microservice.options.events.onError({
-          requestHash,
-          service: {
-            id: this.microservice.serviceId,
-            name: this.microservice.options.name,
-            version: this.microservice.options.version,
-            env: this.microservice.options.env
-          },
-          module: this.moduleName,
-          action: this.actionName,
-          params: args,
-          time: Date.now(),
-          error: error.message
-        });
-      }
+      span?.recordException(error);
+      span?.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+      span?.end();
       throw error;
-    } finally {
-      span.end();
     }
   }
 };

package/package.json

@@ -1,75 +1,84 @@
-{
-  "name": "imean-service-engine",
-  "version": "1.1.0",
-  "description": "microservice engine",
-  "keywords": [
-    "microservice",
-    "websocket",
-    "http",
-    "node"
-  ],
-  "author": "imean",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://git.imean.tech/imean/imean-microservice-framework.git"
-  },
-  "main": "dist/mod.js",
-  "module": "dist/mod.js",
-  "types": "dist/mod.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/mod.d.ts",
-      "import": "./dist/mod.js",
-      "require": "./dist/mod.cjs"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "dev": "tsx dev/index.ts",
-    "build": "tsup",
-    "lint": "deno lint",
-    "fmt": "deno fmt",
-    "test": "vitest",
-    "coverage": "vitest --coverage",
-    "prepublishOnly": "npm run build && npm run test"
-  },
-  "dependencies": {
-    "@hono/node-server": "^1.13.7",
-    "@hono/node-ws": "^1.0.6",
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": "^0.57.1",
-    "dayjs": "^1.11.13",
-    "ejson": "^2.2.3",
-    "etcd3": "^1.1.2",
-    "fs-extra": "^11.3.0",
-    "hono": "^4.6.17",
-    "lru-cache": "^11.0.2",
-    "prettier": "^3.4.2",
-    "winston": "^3.17.0",
-    "zod": "^3.24.1"
-  },
-  "peerDependencies": {
-    "isomorphic-ws": "^5.0.0"
-  },
-  "devDependencies": {
-    "@types/ejson": "^2.2.2",
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^20.0.0",
-    "imean-service-client": "^1.4.4",
-    "tslib": "^2.8.1",
-    "tsup": "^8.0.1",
-    "tsx": "^4.19.2",
-    "typescript": "^5.3.3",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.3"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "imean-service-engine",
+  "version": "1.2.0",
+  "description": "microservice engine",
+  "keywords": [
+    "microservice",
+    "websocket",
+    "http",
+    "node"
+  ],
+  "author": "imean",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.imean.tech/imean/imean-microservice-framework.git"
+  },
+  "main": "dist/mod.js",
+  "module": "dist/mod.js",
+  "types": "dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx dev/index.ts",
+    "build": "tsup",
+    "lint": "deno lint",
+    "fmt": "deno fmt",
+    "test": "vitest",
+    "coverage": "vitest --coverage",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.13.7",
+    "@hono/node-ws": "^1.0.6",
+    "dayjs": "^1.11.13",
+    "ejson": "^2.2.3",
+    "etcd3": "^1.1.2",
+    "fs-extra": "^11.3.0",
+    "hono": "^4.6.17",
+    "lru-cache": "^11.0.2",
+    "prettier": "^3.4.2",
+    "winston": "^3.17.0",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.x"
+  },
+  "devDependencies": {
+    "@opentelemetry/auto-instrumentations-node": "^0.55.3",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.57.1",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.57.1",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.57.1",
+    "@opentelemetry/instrumentation-winston": "^0.44.0",
+    "@opentelemetry/sdk-logs": "^0.57.1",
+    "@opentelemetry/sdk-metrics": "^1.30.1",
+    "@opentelemetry/sdk-node": "^0.57.1",
+    "@opentelemetry/sdk-trace-node": "^1.30.1",
+    "@opentelemetry/winston-transport": "^0.10.0",
+    "@types/ejson": "^2.2.2",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.0.0",
+    "imean-service-client": "^1.5.0",
+    "opentelemetry-instrumentation-fetch-node": "^1.2.3",
+    "tslib": "^2.8.1",
+    "tsup": "^8.0.1",
+    "tsx": "^4.19.2",
+    "typescript": "^5.3.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.3"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}