@ydking0911/observr 0.3.0

package/dist/index.d.mts

@@ -0,0 +1,128 @@
+interface ObservrEvent {
+    timestamp: string;
+    type: "http_request" | "span" | "log";
+    level: "debug" | "info" | "warn" | "error";
+    trace_id?: string;
+    span_id?: string;
+    message: string;
+    service?: string;
+    duration_ms?: number;
+    method?: string;
+    path?: string;
+    status_code?: number;
+    attributes?: Record<string, unknown>;
+}
+interface ObservrConfig {
+    service?: string;
+    collectorUrl?: string;
+    autoInstrument?: boolean;
+    logLevel?: "debug" | "info" | "warn" | "error";
+}
+
+declare class Transport {
+    private readonly collectorUrl;
+    private readonly service;
+    private queue;
+    private timer;
+    private stopped;
+    constructor(collectorUrl: string, service: string);
+    send(event: Omit<ObservrEvent, "service"> & {
+        service?: string;
+    }): void;
+    flush(timeoutMs?: number): Promise<void>;
+    shutdown(): Promise<void>;
+    private _flush;
+    private _postBatch;
+}
+
+declare class Span {
+    readonly name: string;
+    readonly spanId: string;
+    readonly traceId: string;
+    private readonly transport;
+    private readonly attributes;
+    private startTime;
+    constructor(name: string, transport: Transport, attributes?: Record<string, unknown>);
+    setAttribute(key: string, value: unknown): this;
+    /** Run an async function inside this span, emit on completion. */
+    run<T>(fn: (span: this) => Promise<T>): Promise<T>;
+}
+
+declare class ObservrClient {
+    readonly service: string;
+    readonly collectorUrl: string;
+    readonly transport: Transport;
+    private readonly config;
+    private started;
+    constructor(config: Required<ObservrConfig>);
+    start(): void;
+    /** Wrap an async function in a named span. */
+    span(name: string, attributes?: Record<string, unknown>): Span;
+    shutdown(): Promise<void>;
+    private _autoInstrument;
+    private _instrumentExpress;
+    private _instrumentFastify;
+}
+
+type Req = {
+    method: string;
+    path: string;
+    url: string;
+    ip?: string;
+    headers: Record<string, string | string[] | undefined>;
+};
+type Res = {
+    statusCode: number;
+    on: (event: string, fn: () => void) => void;
+};
+type Next = () => void;
+/**
+ * Express middleware factory.
+ * Usage:
+ *   import { expressMiddleware } from "observr";
+ *   app.use(expressMiddleware(transport));
+ */
+declare function expressMiddleware(transport: Transport): (req: Req, res: Res, next: Next) => void;
+
+type FastifyInstance = any;
+/**
+ * Fastify plugin that records HTTP request events via observr.
+ *
+ * Usage (manual registration):
+ *   import { fastifyPlugin } from "observr";
+ *   await app.register(fastifyPlugin(transport));
+ *
+ * The plugin sets `Symbol.for('skip-override')` so it applies to the
+ * root scope and captures all routes regardless of encapsulation.
+ */
+declare function fastifyPlugin(transport: Transport): (app: FastifyInstance, _options: unknown) => Promise<void>;
+
+/**
+ * observr — Zero-config observability for AI agents and developers.
+ *
+ * Usage:
+ *   import observr from "@ydking0911/observr";
+ *   observr.init({ service: "my-api" });
+ *
+ *   // Manual span
+ *   await observr.span("db.query").run(async (span) => {
+ *     const rows = await db.query("SELECT ...");
+ *     span.setAttribute("row_count", rows.length);
+ *     return rows;
+ *   });
+ */
+
+/**
+ * Initialize observr. Call once at application startup.
+ */
+declare function init(config?: ObservrConfig): ObservrClient;
+/**
+ * Return the active client. Throws if init() has not been called.
+ */
+declare function getClient(): ObservrClient;
+declare const observr: {
+    init: typeof init;
+    getClient: typeof getClient;
+};
+
+export { ObservrClient, type ObservrConfig, type ObservrEvent, Span, Transport, observr as default, expressMiddleware, fastifyPlugin, getClient, init };

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+interface ObservrEvent {
+    timestamp: string;
+    type: "http_request" | "span" | "log";
+    level: "debug" | "info" | "warn" | "error";
+    trace_id?: string;
+    span_id?: string;
+    message: string;
+    service?: string;
+    duration_ms?: number;
+    method?: string;
+    path?: string;
+    status_code?: number;
+    attributes?: Record<string, unknown>;
+}
+interface ObservrConfig {
+    service?: string;
+    collectorUrl?: string;
+    autoInstrument?: boolean;
+    logLevel?: "debug" | "info" | "warn" | "error";
+}
+
+declare class Transport {
+    private readonly collectorUrl;
+    private readonly service;
+    private queue;
+    private timer;
+    private stopped;
+    constructor(collectorUrl: string, service: string);
+    send(event: Omit<ObservrEvent, "service"> & {
+        service?: string;
+    }): void;
+    flush(timeoutMs?: number): Promise<void>;
+    shutdown(): Promise<void>;
+    private _flush;
+    private _postBatch;
+}
+
+declare class Span {
+    readonly name: string;
+    readonly spanId: string;
+    readonly traceId: string;
+    private readonly transport;
+    private readonly attributes;
+    private startTime;
+    constructor(name: string, transport: Transport, attributes?: Record<string, unknown>);
+    setAttribute(key: string, value: unknown): this;
+    /** Run an async function inside this span, emit on completion. */
+    run<T>(fn: (span: this) => Promise<T>): Promise<T>;
+}
+
+declare class ObservrClient {
+    readonly service: string;
+    readonly collectorUrl: string;
+    readonly transport: Transport;
+    private readonly config;
+    private started;
+    constructor(config: Required<ObservrConfig>);
+    start(): void;
+    /** Wrap an async function in a named span. */
+    span(name: string, attributes?: Record<string, unknown>): Span;
+    shutdown(): Promise<void>;
+    private _autoInstrument;
+    private _instrumentExpress;
+    private _instrumentFastify;
+}
+
+type Req = {
+    method: string;
+    path: string;
+    url: string;
+    ip?: string;
+    headers: Record<string, string | string[] | undefined>;
+};
+type Res = {
+    statusCode: number;
+    on: (event: string, fn: () => void) => void;
+};
+type Next = () => void;
+/**
+ * Express middleware factory.
+ * Usage:
+ *   import { expressMiddleware } from "observr";
+ *   app.use(expressMiddleware(transport));
+ */
+declare function expressMiddleware(transport: Transport): (req: Req, res: Res, next: Next) => void;
+
+type FastifyInstance = any;
+/**
+ * Fastify plugin that records HTTP request events via observr.
+ *
+ * Usage (manual registration):
+ *   import { fastifyPlugin } from "observr";
+ *   await app.register(fastifyPlugin(transport));
+ *
+ * The plugin sets `Symbol.for('skip-override')` so it applies to the
+ * root scope and captures all routes regardless of encapsulation.
+ */
+declare function fastifyPlugin(transport: Transport): (app: FastifyInstance, _options: unknown) => Promise<void>;
+
+/**
+ * observr — Zero-config observability for AI agents and developers.
+ *
+ * Usage:
+ *   import observr from "@ydking0911/observr";
+ *   observr.init({ service: "my-api" });
+ *
+ *   // Manual span
+ *   await observr.span("db.query").run(async (span) => {
+ *     const rows = await db.query("SELECT ...");
+ *     span.setAttribute("row_count", rows.length);
+ *     return rows;
+ *   });
+ */
+
+/**
+ * Initialize observr. Call once at application startup.
+ */
+declare function init(config?: ObservrConfig): ObservrClient;
+/**
+ * Return the active client. Throws if init() has not been called.
+ */
+declare function getClient(): ObservrClient;
+declare const observr: {
+    init: typeof init;
+    getClient: typeof getClient;
+};
+
+export { ObservrClient, type ObservrConfig, type ObservrEvent, Span, Transport, observr as default, expressMiddleware, fastifyPlugin, getClient, init };

package/dist/index.js

@@ -0,0 +1,420 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/express.ts
+var express_exports = {};
+__export(express_exports, {
+  expressMiddleware: () => expressMiddleware,
+  instrumentExpress: () => instrumentExpress
+});
+function expressMiddleware(transport) {
+  return function observrMiddleware(req, res, next) {
+    const traceId = (0, import_node_crypto2.randomBytes)(16).toString("hex");
+    const spanId = (0, import_node_crypto2.randomBytes)(8).toString("hex");
+    const start = performance.now();
+    res.on("finish", () => {
+      const durationMs = parseFloat((performance.now() - start).toFixed(2));
+      const statusCode = res.statusCode;
+      const level = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+      const path = req.path || req.url || "/";
+      transport.send({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "http_request",
+        level,
+        trace_id: traceId,
+        span_id: spanId,
+        message: `${req.method} ${path}`,
+        method: req.method,
+        path,
+        status_code: statusCode,
+        duration_ms: durationMs,
+        attributes: {
+          remote_addr: req.ip,
+          user_agent: req.headers["user-agent"]
+        }
+      });
+    });
+    next();
+  };
+}
+function instrumentExpress(transport) {
+  try {
+    const express = require("express");
+    if (!express || express.__observr_patched) return;
+    const originalExpress = express.default ?? express;
+    const mw = expressMiddleware(transport);
+    const wrapped = function(...args) {
+      const app = originalExpress(...args);
+      app.use(mw);
+      return app;
+    };
+    Object.assign(wrapped, originalExpress);
+    wrapped.__observr_patched = true;
+    if (express.default) {
+      express.default = wrapped;
+    } else {
+      const Module = require("module");
+      const cached = Module._cache[require.resolve("express")];
+      if (cached) cached.exports = wrapped;
+    }
+  } catch {
+  }
+}
+var import_node_crypto2;
+var init_express = __esm({
+  "src/integrations/express.ts"() {
+    "use strict";
+    import_node_crypto2 = require("crypto");
+  }
+});
+
+// src/integrations/fastify.ts
+var fastify_exports = {};
+__export(fastify_exports, {
+  fastifyPlugin: () => fastifyPlugin,
+  instrumentFastify: () => instrumentFastify
+});
+function fastifyPlugin(transport) {
+  async function plugin(app, _options) {
+    app.addHook(
+      "onResponse",
+      async (request, reply) => {
+        const statusCode = reply.statusCode;
+        const durationMs = parseFloat((reply.elapsedTime ?? 0).toFixed(2));
+        const level = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+        const path = request.routeOptions?.url ?? request.routerPath ?? request.url?.split("?")[0] ?? "/";
+        transport.send({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "http_request",
+          level,
+          trace_id: (0, import_node_crypto3.randomBytes)(16).toString("hex"),
+          span_id: (0, import_node_crypto3.randomBytes)(8).toString("hex"),
+          message: `${request.method} ${path}`,
+          method: request.method,
+          path,
+          status_code: statusCode,
+          duration_ms: durationMs,
+          attributes: {
+            remote_addr: request.ip,
+            user_agent: request.headers?.["user-agent"]
+          }
+        });
+      }
+    );
+  }
+  plugin[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+  return plugin;
+}
+function instrumentFastify(transport) {
+  try {
+    const mod = require("fastify");
+    if (!mod || mod.__observr_patched) return;
+    const original = mod.default ?? mod;
+    const plugin = fastifyPlugin(transport);
+    const wrapped = function(...args) {
+      const app = original(...args);
+      app.register(plugin);
+      return app;
+    };
+    Object.assign(wrapped, original);
+    mod.__observr_patched = true;
+    const Module = require("module");
+    const cached = Module._cache[require.resolve("fastify")];
+    if (cached) {
+      if (mod.default) {
+        mod.default = wrapped;
+        cached.exports.default = wrapped;
+      } else {
+        cached.exports = wrapped;
+      }
+    }
+  } catch {
+  }
+}
+var import_node_crypto3;
+var init_fastify = __esm({
+  "src/integrations/fastify.ts"() {
+    "use strict";
+    import_node_crypto3 = require("crypto");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ObservrClient: () => ObservrClient,
+  Span: () => Span,
+  Transport: () => Transport,
+  default: () => index_default,
+  expressMiddleware: () => expressMiddleware,
+  fastifyPlugin: () => fastifyPlugin,
+  getClient: () => getClient,
+  init: () => init
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/transport.ts
+var BATCH_SIZE = 50;
+var FLUSH_INTERVAL_MS = 1e3;
+var Transport = class {
+  constructor(collectorUrl, service) {
+    this.queue = [];
+    this.timer = null;
+    this.stopped = false;
+    this.collectorUrl = collectorUrl.replace(/\/$/, "");
+    this.service = service;
+    this.timer = setInterval(() => this._flush(), FLUSH_INTERVAL_MS);
+    if (this.timer.unref) this.timer.unref();
+  }
+  send(event) {
+    if (this.stopped) return;
+    const full = { service: this.service, ...event };
+    if (this.queue.length >= 1e4) return;
+    this.queue.push(full);
+    if (this.queue.length >= BATCH_SIZE) this._flush();
+  }
+  async flush(timeoutMs = 5e3) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.queue.length > 0 && Date.now() < deadline) {
+      await this._flush();
+      if (this.queue.length > 0) await sleep(50);
+    }
+  }
+  async shutdown() {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  _flush() {
+    if (this.queue.length === 0) return Promise.resolve();
+    const batch = this.queue.splice(0, BATCH_SIZE);
+    return this._postBatch(batch);
+  }
+  async _postBatch(batch) {
+    try {
+      const url = `${this.collectorUrl}/events`;
+      await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ events: batch }),
+        signal: AbortSignal.timeout(3e3)
+      });
+    } catch {
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/logger.ts
+var LEVEL_RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var CONSOLE_MAP = {
+  debug: "debug",
+  info: "log",
+  warn: "warn",
+  error: "error"
+};
+var originals = /* @__PURE__ */ new Map();
+function patchConsole(transport, minLevel) {
+  const levels = ["debug", "info", "warn", "error"];
+  for (const level of levels) {
+    const consoleKey = CONSOLE_MAP[level];
+    const original = console[consoleKey];
+    originals.set(level, original);
+    console[consoleKey] = (...args) => {
+      original.apply(console, args);
+      if (LEVEL_RANK[level] >= LEVEL_RANK[minLevel]) {
+        const message = args.map(
+          (a) => typeof a === "string" ? a : JSON.stringify(a)
+        ).join(" ");
+        transport.send({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "log",
+          level,
+          message,
+          attributes: {}
+        });
+      }
+    };
+  }
+}
+function unpatchConsole() {
+  for (const [level, original] of originals) {
+    const consoleKey = CONSOLE_MAP[level];
+    console[consoleKey] = original;
+  }
+  originals.clear();
+}
+
+// src/span.ts
+var import_node_crypto = require("crypto");
+var Span = class {
+  constructor(name, transport, attributes = {}) {
+    this.startTime = 0;
+    this.name = name;
+    this.spanId = (0, import_node_crypto.randomBytes)(8).toString("hex");
+    this.traceId = (0, import_node_crypto.randomBytes)(16).toString("hex");
+    this.transport = transport;
+    this.attributes = { ...attributes };
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+    return this;
+  }
+  /** Run an async function inside this span, emit on completion. */
+  async run(fn) {
+    this.startTime = performance.now();
+    let level = "info";
+    let exceptionMsg;
+    try {
+      const result = await fn(this);
+      return result;
+    } catch (err) {
+      level = "error";
+      exceptionMsg = err instanceof Error ? err.stack ?? err.message : String(err);
+      throw err;
+    } finally {
+      const durationMs = parseFloat(
+        (performance.now() - this.startTime).toFixed(2)
+      );
+      if (exceptionMsg) this.attributes["exception"] = exceptionMsg;
+      this.transport.send({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "span",
+        level,
+        trace_id: this.traceId,
+        span_id: this.spanId,
+        message: this.name,
+        duration_ms: durationMs,
+        attributes: this.attributes
+      });
+    }
+  }
+};
+
+// src/client.ts
+var ObservrClient = class {
+  constructor(config) {
+    this.started = false;
+    this.config = config;
+    this.service = config.service;
+    this.collectorUrl = config.collectorUrl;
+    this.transport = new Transport(config.collectorUrl, config.service);
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    patchConsole(this.transport, this.config.logLevel);
+    if (this.config.autoInstrument) {
+      this._autoInstrument();
+    }
+  }
+  /** Wrap an async function in a named span. */
+  span(name, attributes = {}) {
+    return new Span(name, this.transport, attributes);
+  }
+  async shutdown() {
+    unpatchConsole();
+    await this.transport.shutdown();
+    this.started = false;
+  }
+  _autoInstrument() {
+    if (typeof require !== "undefined") {
+      try {
+        require("express");
+        this._instrumentExpress();
+      } catch {
+      }
+      try {
+        require("fastify");
+        this._instrumentFastify();
+      } catch {
+      }
+    }
+  }
+  _instrumentExpress() {
+    try {
+      const { instrumentExpress: instrumentExpress2 } = (init_express(), __toCommonJS(express_exports));
+      instrumentExpress2(this.transport);
+    } catch {
+    }
+  }
+  _instrumentFastify() {
+    try {
+      const { instrumentFastify: instrumentFastify2 } = (init_fastify(), __toCommonJS(fastify_exports));
+      instrumentFastify2(this.transport);
+    } catch {
+    }
+  }
+};
+
+// src/index.ts
+init_express();
+init_fastify();
+var _client = null;
+function init(config = {}) {
+  _client = new ObservrClient({
+    service: config.service ?? "app",
+    collectorUrl: config.collectorUrl ?? "http://localhost:7676",
+    autoInstrument: config.autoInstrument ?? true,
+    logLevel: config.logLevel ?? "debug"
+  });
+  _client.start();
+  return _client;
+}
+function getClient() {
+  if (!_client) {
+    throw new Error("observr.init() must be called before getClient()");
+  }
+  return _client;
+}
+var observr = { init, getClient };
+var index_default = observr;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObservrClient,
+  Span,
+  Transport,
+  expressMiddleware,
+  fastifyPlugin,
+  getClient,
+  init
+});

package/dist/index.mjs

@@ -0,0 +1,399 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/express.ts
+var express_exports = {};
+__export(express_exports, {
+  expressMiddleware: () => expressMiddleware,
+  instrumentExpress: () => instrumentExpress
+});
+import { randomBytes as randomBytes2 } from "crypto";
+function expressMiddleware(transport) {
+  return function observrMiddleware(req, res, next) {
+    const traceId = randomBytes2(16).toString("hex");
+    const spanId = randomBytes2(8).toString("hex");
+    const start = performance.now();
+    res.on("finish", () => {
+      const durationMs = parseFloat((performance.now() - start).toFixed(2));
+      const statusCode = res.statusCode;
+      const level = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+      const path = req.path || req.url || "/";
+      transport.send({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "http_request",
+        level,
+        trace_id: traceId,
+        span_id: spanId,
+        message: `${req.method} ${path}`,
+        method: req.method,
+        path,
+        status_code: statusCode,
+        duration_ms: durationMs,
+        attributes: {
+          remote_addr: req.ip,
+          user_agent: req.headers["user-agent"]
+        }
+      });
+    });
+    next();
+  };
+}
+function instrumentExpress(transport) {
+  try {
+    const express = __require("express");
+    if (!express || express.__observr_patched) return;
+    const originalExpress = express.default ?? express;
+    const mw = expressMiddleware(transport);
+    const wrapped = function(...args) {
+      const app = originalExpress(...args);
+      app.use(mw);
+      return app;
+    };
+    Object.assign(wrapped, originalExpress);
+    wrapped.__observr_patched = true;
+    if (express.default) {
+      express.default = wrapped;
+    } else {
+      const Module = __require("module");
+      const cached = Module._cache[__require.resolve("express")];
+      if (cached) cached.exports = wrapped;
+    }
+  } catch {
+  }
+}
+var init_express = __esm({
+  "src/integrations/express.ts"() {
+    "use strict";
+  }
+});
+
+// src/integrations/fastify.ts
+var fastify_exports = {};
+__export(fastify_exports, {
+  fastifyPlugin: () => fastifyPlugin,
+  instrumentFastify: () => instrumentFastify
+});
+import { randomBytes as randomBytes3 } from "crypto";
+function fastifyPlugin(transport) {
+  async function plugin(app, _options) {
+    app.addHook(
+      "onResponse",
+      async (request, reply) => {
+        const statusCode = reply.statusCode;
+        const durationMs = parseFloat((reply.elapsedTime ?? 0).toFixed(2));
+        const level = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+        const path = request.routeOptions?.url ?? request.routerPath ?? request.url?.split("?")[0] ?? "/";
+        transport.send({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "http_request",
+          level,
+          trace_id: randomBytes3(16).toString("hex"),
+          span_id: randomBytes3(8).toString("hex"),
+          message: `${request.method} ${path}`,
+          method: request.method,
+          path,
+          status_code: statusCode,
+          duration_ms: durationMs,
+          attributes: {
+            remote_addr: request.ip,
+            user_agent: request.headers?.["user-agent"]
+          }
+        });
+      }
+    );
+  }
+  plugin[/* @__PURE__ */ Symbol.for("skip-override")] = true;
+  return plugin;
+}
+function instrumentFastify(transport) {
+  try {
+    const mod = __require("fastify");
+    if (!mod || mod.__observr_patched) return;
+    const original = mod.default ?? mod;
+    const plugin = fastifyPlugin(transport);
+    const wrapped = function(...args) {
+      const app = original(...args);
+      app.register(plugin);
+      return app;
+    };
+    Object.assign(wrapped, original);
+    mod.__observr_patched = true;
+    const Module = __require("module");
+    const cached = Module._cache[__require.resolve("fastify")];
+    if (cached) {
+      if (mod.default) {
+        mod.default = wrapped;
+        cached.exports.default = wrapped;
+      } else {
+        cached.exports = wrapped;
+      }
+    }
+  } catch {
+  }
+}
+var init_fastify = __esm({
+  "src/integrations/fastify.ts"() {
+    "use strict";
+  }
+});
+
+// src/transport.ts
+var BATCH_SIZE = 50;
+var FLUSH_INTERVAL_MS = 1e3;
+var Transport = class {
+  constructor(collectorUrl, service) {
+    this.queue = [];
+    this.timer = null;
+    this.stopped = false;
+    this.collectorUrl = collectorUrl.replace(/\/$/, "");
+    this.service = service;
+    this.timer = setInterval(() => this._flush(), FLUSH_INTERVAL_MS);
+    if (this.timer.unref) this.timer.unref();
+  }
+  send(event) {
+    if (this.stopped) return;
+    const full = { service: this.service, ...event };
+    if (this.queue.length >= 1e4) return;
+    this.queue.push(full);
+    if (this.queue.length >= BATCH_SIZE) this._flush();
+  }
+  async flush(timeoutMs = 5e3) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.queue.length > 0 && Date.now() < deadline) {
+      await this._flush();
+      if (this.queue.length > 0) await sleep(50);
+    }
+  }
+  async shutdown() {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  _flush() {
+    if (this.queue.length === 0) return Promise.resolve();
+    const batch = this.queue.splice(0, BATCH_SIZE);
+    return this._postBatch(batch);
+  }
+  async _postBatch(batch) {
+    try {
+      const url = `${this.collectorUrl}/events`;
+      await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ events: batch }),
+        signal: AbortSignal.timeout(3e3)
+      });
+    } catch {
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/logger.ts
+var LEVEL_RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var CONSOLE_MAP = {
+  debug: "debug",
+  info: "log",
+  warn: "warn",
+  error: "error"
+};
+var originals = /* @__PURE__ */ new Map();
+function patchConsole(transport, minLevel) {
+  const levels = ["debug", "info", "warn", "error"];
+  for (const level of levels) {
+    const consoleKey = CONSOLE_MAP[level];
+    const original = console[consoleKey];
+    originals.set(level, original);
+    console[consoleKey] = (...args) => {
+      original.apply(console, args);
+      if (LEVEL_RANK[level] >= LEVEL_RANK[minLevel]) {
+        const message = args.map(
+          (a) => typeof a === "string" ? a : JSON.stringify(a)
+        ).join(" ");
+        transport.send({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "log",
+          level,
+          message,
+          attributes: {}
+        });
+      }
+    };
+  }
+}
+function unpatchConsole() {
+  for (const [level, original] of originals) {
+    const consoleKey = CONSOLE_MAP[level];
+    console[consoleKey] = original;
+  }
+  originals.clear();
+}
+
+// src/span.ts
+import { randomBytes } from "crypto";
+var Span = class {
+  constructor(name, transport, attributes = {}) {
+    this.startTime = 0;
+    this.name = name;
+    this.spanId = randomBytes(8).toString("hex");
+    this.traceId = randomBytes(16).toString("hex");
+    this.transport = transport;
+    this.attributes = { ...attributes };
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+    return this;
+  }
+  /** Run an async function inside this span, emit on completion. */
+  async run(fn) {
+    this.startTime = performance.now();
+    let level = "info";
+    let exceptionMsg;
+    try {
+      const result = await fn(this);
+      return result;
+    } catch (err) {
+      level = "error";
+      exceptionMsg = err instanceof Error ? err.stack ?? err.message : String(err);
+      throw err;
+    } finally {
+      const durationMs = parseFloat(
+        (performance.now() - this.startTime).toFixed(2)
+      );
+      if (exceptionMsg) this.attributes["exception"] = exceptionMsg;
+      this.transport.send({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "span",
+        level,
+        trace_id: this.traceId,
+        span_id: this.spanId,
+        message: this.name,
+        duration_ms: durationMs,
+        attributes: this.attributes
+      });
+    }
+  }
+};
+
+// src/client.ts
+var ObservrClient = class {
+  constructor(config) {
+    this.started = false;
+    this.config = config;
+    this.service = config.service;
+    this.collectorUrl = config.collectorUrl;
+    this.transport = new Transport(config.collectorUrl, config.service);
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    patchConsole(this.transport, this.config.logLevel);
+    if (this.config.autoInstrument) {
+      this._autoInstrument();
+    }
+  }
+  /** Wrap an async function in a named span. */
+  span(name, attributes = {}) {
+    return new Span(name, this.transport, attributes);
+  }
+  async shutdown() {
+    unpatchConsole();
+    await this.transport.shutdown();
+    this.started = false;
+  }
+  _autoInstrument() {
+    if (typeof __require !== "undefined") {
+      try {
+        __require("express");
+        this._instrumentExpress();
+      } catch {
+      }
+      try {
+        __require("fastify");
+        this._instrumentFastify();
+      } catch {
+      }
+    }
+  }
+  _instrumentExpress() {
+    try {
+      const { instrumentExpress: instrumentExpress2 } = (init_express(), __toCommonJS(express_exports));
+      instrumentExpress2(this.transport);
+    } catch {
+    }
+  }
+  _instrumentFastify() {
+    try {
+      const { instrumentFastify: instrumentFastify2 } = (init_fastify(), __toCommonJS(fastify_exports));
+      instrumentFastify2(this.transport);
+    } catch {
+    }
+  }
+};
+
+// src/index.ts
+init_express();
+init_fastify();
+var _client = null;
+function init(config = {}) {
+  _client = new ObservrClient({
+    service: config.service ?? "app",
+    collectorUrl: config.collectorUrl ?? "http://localhost:7676",
+    autoInstrument: config.autoInstrument ?? true,
+    logLevel: config.logLevel ?? "debug"
+  });
+  _client.start();
+  return _client;
+}
+function getClient() {
+  if (!_client) {
+    throw new Error("observr.init() must be called before getClient()");
+  }
+  return _client;
+}
+var observr = { init, getClient };
+var index_default = observr;
+export {
+  ObservrClient,
+  Span,
+  Transport,
+  index_default as default,
+  expressMiddleware,
+  fastifyPlugin,
+  getClient,
+  init
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@ydking0911/observr",
+  "version": "0.3.0",
+  "description": "Zero-config observability for AI agents and developers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "observability",
+    "tracing",
+    "logging",
+    "ai",
+    "devtools",
+    "apm"
+  ],
+  "author": "ydking0911",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ydking0911/observr.git",
+    "directory": "sdk/node"
+  },
+  "homepage": "https://github.com/ydking0911/observr",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "fastify": "^4.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.5.0"
+  },
+  "peerDependencies": {
+    "express": ">=4.0.0",
+    "fastify": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}