@gravito/monitor 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,955 @@
+// src/config.ts
+function defineMonitorConfig(config) {
+  return config;
+}
+
+// src/health/HealthController.ts
+var HealthController = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * GET /health - Full health check with all registered checks
+   */
+  async health(c) {
+    const report = await this.registry.check();
+    const status = report.status === "healthy" ? 200 : report.status === "degraded" ? 200 : 503;
+    return c.json(report, status);
+  }
+  /**
+   * GET /ready - Kubernetes readiness probe
+   * Returns 200 if ready to serve traffic, 503 otherwise
+   */
+  async ready(c) {
+    const result = await this.registry.readiness();
+    if (result.status === "healthy") {
+      return c.json({ status: "ready" }, 200);
+    }
+    return c.json({ status: "not_ready", reason: result.reason }, 503);
+  }
+  /**
+   * GET /live - Kubernetes liveness probe
+   * Returns 200 if the process is alive
+   */
+  async live(c) {
+    const result = await this.registry.liveness();
+    return c.json({ status: "alive" }, result.status === "healthy" ? 200 : 503);
+  }
+};
+
+// src/health/HealthRegistry.ts
+var DEFAULTS = {
+  timeout: 5e3,
+  cacheTtl: 0
+};
+var HealthRegistry = class {
+  checks = /* @__PURE__ */ new Map();
+  startTime = Date.now();
+  cachedReport = null;
+  cacheExpiry = 0;
+  timeout;
+  cacheTtl;
+  constructor(config = {}) {
+    this.timeout = config.timeout ?? DEFAULTS.timeout;
+    this.cacheTtl = config.cacheTtl ?? DEFAULTS.cacheTtl;
+  }
+  /**
+   * Register a health check
+   */
+  register(name, check) {
+    this.checks.set(name, check);
+    return this;
+  }
+  /**
+   * Unregister a health check
+   */
+  unregister(name) {
+    return this.checks.delete(name);
+  }
+  /**
+   * Get all registered check names
+   */
+  getCheckNames() {
+    return Array.from(this.checks.keys());
+  }
+  /**
+   * Execute a single health check with timeout
+   */
+  async executeCheck(name, check) {
+    const start = performance.now();
+    try {
+      const result = await Promise.race([
+        Promise.resolve(check()),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), this.timeout)
+        )
+      ]);
+      const latency = Math.round(performance.now() - start);
+      return {
+        name,
+        ...result,
+        latency
+      };
+    } catch (error) {
+      const latency = Math.round(performance.now() - start);
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        name,
+        status: "unhealthy",
+        message,
+        latency
+      };
+    }
+  }
+  /**
+   * Execute all health checks and generate report
+   */
+  async check() {
+    if (this.cacheTtl > 0 && this.cachedReport && Date.now() < this.cacheExpiry) {
+      return this.cachedReport;
+    }
+    const results = await Promise.all(
+      Array.from(this.checks.entries()).map(([name, check]) => this.executeCheck(name, check))
+    );
+    const checks = {};
+    let overallStatus = "healthy";
+    for (const result of results) {
+      checks[result.name] = result;
+      if (result.status === "unhealthy") {
+        overallStatus = "unhealthy";
+      } else if (result.status === "degraded" && overallStatus !== "unhealthy") {
+        overallStatus = "degraded";
+      }
+    }
+    const report = {
+      status: overallStatus,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: Math.round((Date.now() - this.startTime) / 1e3),
+      checks
+    };
+    if (this.cacheTtl > 0) {
+      this.cachedReport = report;
+      this.cacheExpiry = Date.now() + this.cacheTtl;
+    }
+    return report;
+  }
+  /**
+   * Simple liveness check (is the process running?)
+   */
+  async liveness() {
+    return { status: "healthy" };
+  }
+  /**
+   * Readiness check (is the app ready to serve traffic?)
+   * By default, requires all checks to be healthy
+   */
+  async readiness() {
+    if (this.checks.size === 0) {
+      return { status: "healthy" };
+    }
+    const report = await this.check();
+    if (report.status === "unhealthy") {
+      const failedChecks = Object.entries(report.checks).filter(([_, r]) => r.status === "unhealthy").map(([name]) => name);
+      return {
+        status: "unhealthy",
+        reason: `Failed checks: ${failedChecks.join(", ")}`
+      };
+    }
+    return { status: "healthy" };
+  }
+};
+
+// src/health/index.ts
+function createDatabaseCheck(connectionFn) {
+  return async () => {
+    try {
+      const isConnected = await connectionFn();
+      return isConnected ? { status: "healthy", message: "Database connected" } : { status: "unhealthy", message: "Database disconnected" };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : "Database check failed"
+      };
+    }
+  };
+}
+function createRedisCheck(pingFn) {
+  return async () => {
+    try {
+      const result = await pingFn();
+      return result === "PONG" ? { status: "healthy", message: "Redis connected" } : { status: "unhealthy", message: `Unexpected response: ${result}` };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : "Redis check failed"
+      };
+    }
+  };
+}
+function createMemoryCheck(options) {
+  const maxPercent = options?.maxHeapUsedPercent ?? 90;
+  return () => {
+    const usage = process.memoryUsage();
+    const heapUsedPercent = usage.heapUsed / usage.heapTotal * 100;
+    if (heapUsedPercent > maxPercent) {
+      return {
+        status: "degraded",
+        message: `Heap usage at ${heapUsedPercent.toFixed(1)}%`,
+        details: {
+          heapUsed: formatBytes(usage.heapUsed),
+          heapTotal: formatBytes(usage.heapTotal),
+          heapUsedPercent: heapUsedPercent.toFixed(1),
+          rss: formatBytes(usage.rss)
+        }
+      };
+    }
+    return {
+      status: "healthy",
+      message: "Memory usage normal",
+      details: {
+        heapUsed: formatBytes(usage.heapUsed),
+        heapTotal: formatBytes(usage.heapTotal),
+        heapUsedPercent: heapUsedPercent.toFixed(1),
+        rss: formatBytes(usage.rss)
+      }
+    };
+  };
+}
+function createHttpCheck(url, options) {
+  const timeout = options?.timeout ?? 5e3;
+  const expectedStatus = options?.expectedStatus ?? 200;
+  const method = options?.method ?? "GET";
+  return async () => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const start = performance.now();
+      const response = await fetch(url, {
+        method,
+        signal: controller.signal
+      });
+      const latency = Math.round(performance.now() - start);
+      clearTimeout(timeoutId);
+      if (response.status === expectedStatus) {
+        return {
+          status: "healthy",
+          message: `${url} responded with ${response.status}`,
+          latency
+        };
+      }
+      return {
+        status: "unhealthy",
+        message: `Expected ${expectedStatus}, got ${response.status}`,
+        latency
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : "HTTP check failed"
+      };
+    }
+  };
+}
+function createDiskCheck(options) {
+  const minFreePercent = options?.minFreePercent ?? 10;
+  return async () => {
+    try {
+      return {
+        status: "healthy",
+        message: "Disk check passed",
+        details: {
+          minFreePercent
+        }
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : "Disk check failed"
+      };
+    }
+  };
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+
+// src/metrics/MetricsController.ts
+var MetricsController = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * GET /metrics - Prometheus metrics endpoint
+   */
+  async metrics(c) {
+    const prometheusFormat = this.registry.toPrometheus();
+    return new Response(prometheusFormat, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/plain; version=0.0.4; charset=utf-8"
+      }
+    });
+  }
+};
+
+// src/metrics/MetricsRegistry.ts
+var DEFAULTS2 = {
+  prefix: "gravito_",
+  defaultMetrics: true,
+  defaultLabels: {}
+};
+var Counter = class {
+  constructor(name, help, labelNames = []) {
+    this.name = name;
+    this.help = help;
+    this.labelNames = labelNames;
+  }
+  values = /* @__PURE__ */ new Map();
+  /**
+   * Increment the counter
+   */
+  inc(labels = {}, delta = 1) {
+    const key = this.labelsToKey(labels);
+    const current = this.values.get(key) ?? 0;
+    this.values.set(key, current + delta);
+  }
+  /**
+   * Get current values
+   */
+  getValues() {
+    const result = [];
+    for (const [key, value] of this.values) {
+      result.push({
+        value,
+        labels: this.keyToLabels(key)
+      });
+    }
+    return result;
+  }
+  /**
+   * Reset all values
+   */
+  reset() {
+    this.values.clear();
+  }
+  labelsToKey(labels) {
+    if (this.labelNames.length === 0) return "__default__";
+    return this.labelNames.map((name) => `${name}=${labels[name] ?? ""}`).join(",");
+  }
+  keyToLabels(key) {
+    if (key === "__default__") return {};
+    const labels = {};
+    for (const part of key.split(",")) {
+      const [name, value] = part.split("=");
+      if (name) labels[name] = value ?? "";
+    }
+    return labels;
+  }
+};
+var Gauge = class {
+  constructor(name, help, labelNames = []) {
+    this.name = name;
+    this.help = help;
+    this.labelNames = labelNames;
+  }
+  values = /* @__PURE__ */ new Map();
+  /**
+   * Set the gauge value
+   */
+  set(value, labels = {}) {
+    const key = this.labelsToKey(labels);
+    this.values.set(key, value);
+  }
+  /**
+   * Increment the gauge
+   */
+  inc(labels = {}, delta = 1) {
+    const key = this.labelsToKey(labels);
+    const current = this.values.get(key) ?? 0;
+    this.values.set(key, current + delta);
+  }
+  /**
+   * Decrement the gauge
+   */
+  dec(labels = {}, delta = 1) {
+    this.inc(labels, -delta);
+  }
+  /**
+   * Get current values
+   */
+  getValues() {
+    const result = [];
+    for (const [key, value] of this.values) {
+      result.push({
+        value,
+        labels: this.keyToLabels(key)
+      });
+    }
+    return result;
+  }
+  labelsToKey(labels) {
+    if (this.labelNames.length === 0) return "__default__";
+    return this.labelNames.map((name) => `${name}=${labels[name] ?? ""}`).join(",");
+  }
+  keyToLabels(key) {
+    if (key === "__default__") return {};
+    const labels = {};
+    for (const part of key.split(",")) {
+      const [name, value] = part.split("=");
+      if (name) labels[name] = value ?? "";
+    }
+    return labels;
+  }
+};
+var Histogram = class {
+  constructor(name, help, labelNames = [], buckets = [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10]) {
+    this.name = name;
+    this.help = help;
+    this.labelNames = labelNames;
+    this.buckets = [...buckets].sort((a, b) => a - b);
+  }
+  bucketCounts = /* @__PURE__ */ new Map();
+  sums = /* @__PURE__ */ new Map();
+  counts = /* @__PURE__ */ new Map();
+  buckets;
+  /**
+   * Observe a value
+   */
+  observe(value, labels = {}) {
+    const key = this.labelsToKey(labels);
+    this.sums.set(key, (this.sums.get(key) ?? 0) + value);
+    this.counts.set(key, (this.counts.get(key) ?? 0) + 1);
+    let bucketMap = this.bucketCounts.get(key);
+    if (!bucketMap) {
+      bucketMap = /* @__PURE__ */ new Map();
+      this.bucketCounts.set(key, bucketMap);
+    }
+    for (const bucket of this.buckets) {
+      if (value <= bucket) {
+        bucketMap.set(bucket, (bucketMap.get(bucket) ?? 0) + 1);
+      }
+    }
+  }
+  /**
+   * Start a timer and return a function to stop it
+   */
+  startTimer(labels = {}) {
+    const start = performance.now();
+    return () => {
+      const duration = (performance.now() - start) / 1e3;
+      this.observe(duration, labels);
+    };
+  }
+  /**
+   * Get values for Prometheus format
+   */
+  getValues() {
+    return {
+      buckets: this.bucketCounts,
+      sums: this.sums,
+      counts: this.counts
+    };
+  }
+  labelsToKey(labels) {
+    if (this.labelNames.length === 0) return "__default__";
+    return this.labelNames.map((name) => `${name}=${labels[name] ?? ""}`).join(",");
+  }
+};
+var MetricsRegistry = class {
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  startTime = Date.now();
+  prefix;
+  defaultLabels;
+  collectDefaultMetrics;
+  constructor(config = {}) {
+    this.prefix = config.prefix ?? DEFAULTS2.prefix;
+    this.defaultLabels = config.defaultLabels ?? DEFAULTS2.defaultLabels;
+    this.collectDefaultMetrics = config.defaultMetrics ?? DEFAULTS2.defaultMetrics;
+    if (this.collectDefaultMetrics) {
+      this.initDefaultMetrics();
+    }
+  }
+  /**
+   * Create or get a counter
+   */
+  counter(options) {
+    const name = this.prefix + options.name;
+    if (!this.counters.has(name)) {
+      this.counters.set(name, new Counter(name, options.help, options.labels));
+    }
+    return this.counters.get(name);
+  }
+  /**
+   * Create or get a gauge
+   */
+  gauge(options) {
+    const name = this.prefix + options.name;
+    if (!this.gauges.has(name)) {
+      this.gauges.set(name, new Gauge(name, options.help, options.labels));
+    }
+    return this.gauges.get(name);
+  }
+  /**
+   * Create or get a histogram
+   */
+  histogram(options) {
+    const name = this.prefix + options.name;
+    if (!this.histograms.has(name)) {
+      this.histograms.set(name, new Histogram(name, options.help, options.labels, options.buckets));
+    }
+    return this.histograms.get(name);
+  }
+  /**
+   * Initialize default runtime metrics
+   */
+  initDefaultMetrics() {
+    this.gauge({
+      name: "process_uptime_seconds",
+      help: "Process uptime in seconds"
+    });
+    this.gauge({
+      name: "nodejs_heap_size_used_bytes",
+      help: "Current heap size used in bytes"
+    });
+    this.gauge({
+      name: "nodejs_heap_size_total_bytes",
+      help: "Total heap size in bytes"
+    });
+    this.gauge({
+      name: "nodejs_external_memory_bytes",
+      help: "External memory usage in bytes"
+    });
+    this.counter({
+      name: "http_requests_total",
+      help: "Total HTTP requests",
+      labels: ["method", "path", "status"]
+    });
+    this.histogram({
+      name: "http_request_duration_seconds",
+      help: "HTTP request duration in seconds",
+      labels: ["method", "path", "status"],
+      buckets: [0.01, 0.05, 0.1, 0.5, 1, 5]
+    });
+  }
+  /**
+   * Update default metrics with current values
+   */
+  updateDefaultMetrics() {
+    if (!this.collectDefaultMetrics) return;
+    const uptime = (Date.now() - this.startTime) / 1e3;
+    this.gauges.get(this.prefix + "process_uptime_seconds")?.set(uptime);
+    const memory = process.memoryUsage();
+    this.gauges.get(this.prefix + "nodejs_heap_size_used_bytes")?.set(memory.heapUsed);
+    this.gauges.get(this.prefix + "nodejs_heap_size_total_bytes")?.set(memory.heapTotal);
+    this.gauges.get(this.prefix + "nodejs_external_memory_bytes")?.set(memory.external);
+  }
+  /**
+   * Export metrics in Prometheus format
+   */
+  toPrometheus() {
+    this.updateDefaultMetrics();
+    const lines = [];
+    for (const counter of this.counters.values()) {
+      lines.push(`# HELP ${counter.name} ${counter.help}`);
+      lines.push(`# TYPE ${counter.name} counter`);
+      for (const { value, labels } of counter.getValues()) {
+        const allLabels = this.formatLabels({ ...this.defaultLabels, ...labels });
+        lines.push(`${counter.name}${allLabels} ${value}`);
+      }
+    }
+    for (const gauge of this.gauges.values()) {
+      lines.push(`# HELP ${gauge.name} ${gauge.help}`);
+      lines.push(`# TYPE ${gauge.name} gauge`);
+      for (const { value, labels } of gauge.getValues()) {
+        const allLabels = this.formatLabels({ ...this.defaultLabels, ...labels });
+        lines.push(`${gauge.name}${allLabels} ${value}`);
+      }
+    }
+    for (const hist of this.histograms.values()) {
+      lines.push(`# HELP ${hist.name} ${hist.help}`);
+      lines.push(`# TYPE ${hist.name} histogram`);
+      const values = hist.getValues();
+      for (const [key, bucketMap] of values.buckets) {
+        const labels = this.keyToLabels(key);
+        let cumulative = 0;
+        for (const bucket of hist.buckets) {
+          cumulative += bucketMap.get(bucket) ?? 0;
+          const allLabels = this.formatLabels({
+            ...this.defaultLabels,
+            ...labels,
+            le: String(bucket)
+          });
+          lines.push(`${hist.name}_bucket${allLabels} ${cumulative}`);
+        }
+        const infLabels = this.formatLabels({ ...this.defaultLabels, ...labels, le: "+Inf" });
+        lines.push(`${hist.name}_bucket${infLabels} ${values.counts.get(key) ?? 0}`);
+        const sumLabels = this.formatLabels({ ...this.defaultLabels, ...labels });
+        lines.push(`${hist.name}_sum${sumLabels} ${values.sums.get(key) ?? 0}`);
+        lines.push(`${hist.name}_count${sumLabels} ${values.counts.get(key) ?? 0}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  formatLabels(labels) {
+    const entries = Object.entries(labels);
+    if (entries.length === 0) return "";
+    return `{${entries.map(([k, v]) => `${k}="${v}"`).join(",")}}`;
+  }
+  keyToLabels(key) {
+    if (key === "__default__") return {};
+    const labels = {};
+    for (const part of key.split(",")) {
+      const [name, value] = part.split("=");
+      if (name) labels[name] = value ?? "";
+    }
+    return labels;
+  }
+};
+
+// src/metrics/index.ts
+function createHttpMetricsMiddleware(registry) {
+  const requestCounter = registry.counter({
+    name: "http_requests_total",
+    help: "Total HTTP requests",
+    labels: ["method", "path", "status"]
+  });
+  const requestDuration = registry.histogram({
+    name: "http_request_duration_seconds",
+    help: "HTTP request duration in seconds",
+    labels: ["method", "path", "status"],
+    buckets: [0.01, 0.05, 0.1, 0.5, 1, 5]
+  });
+  return async (c, next) => {
+    const method = c.req.method;
+    const path = normalizePath(c.req.path);
+    const start = performance.now();
+    await next();
+    const duration = (performance.now() - start) / 1e3;
+    const status = "200";
+    requestCounter.inc({ method, path, status });
+    requestDuration.observe(duration, { method, path, status });
+    return void 0;
+  };
+}
+function normalizePath(path) {
+  path = path.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, ":id");
+  path = path.replace(/\/\d+/g, "/:id");
+  path = path.replace(/\/[a-zA-Z0-9]{32,}/g, "/:token");
+  return path;
+}
+
+// src/tracing/TracingManager.ts
+var DEFAULTS3 = {
+  serviceName: "gravito-app",
+  serviceVersion: "1.0.0",
+  endpoint: "http://localhost:4318/v1/traces",
+  sampleRate: 1,
+  resourceAttributes: {}
+};
+var activeSpan = null;
+var TracingManager = class {
+  otelSdk = null;
+  spans = [];
+  isInitialized = false;
+  serviceName;
+  serviceVersion;
+  endpoint;
+  resourceAttributes;
+  constructor(config = {}) {
+    this.serviceName = config.serviceName ?? DEFAULTS3.serviceName;
+    this.serviceVersion = config.serviceVersion ?? DEFAULTS3.serviceVersion;
+    this.endpoint = config.endpoint ?? DEFAULTS3.endpoint;
+    this.resourceAttributes = config.resourceAttributes ?? DEFAULTS3.resourceAttributes;
+  }
+  /**
+   * Initialize OpenTelemetry SDK if available
+   */
+  async initialize() {
+    if (this.isInitialized) return;
+    try {
+      const [
+        { NodeSDK },
+        { OTLPTraceExporter },
+        { Resource },
+        { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION }
+      ] = await Promise.all([
+        import("@opentelemetry/sdk-node"),
+        import("@opentelemetry/exporter-trace-otlp-http"),
+        import("@opentelemetry/resources"),
+        import("@opentelemetry/semantic-conventions")
+      ]);
+      const resource = new Resource({
+        [ATTR_SERVICE_NAME]: this.serviceName,
+        [ATTR_SERVICE_VERSION]: this.serviceVersion,
+        ...this.resourceAttributes
+      });
+      const traceExporter = new OTLPTraceExporter({
+        url: this.endpoint
+      });
+      this.otelSdk = new NodeSDK({
+        resource,
+        traceExporter
+      });
+      await this.otelSdk.start();
+      this.isInitialized = true;
+      console.log(`[Monitor] OpenTelemetry initialized - exporting to ${this.endpoint}`);
+    } catch {
+      console.log("[Monitor] OpenTelemetry packages not available, using lightweight tracing");
+      this.isInitialized = true;
+    }
+  }
+  /**
+   * Shutdown tracing
+   */
+  async shutdown() {
+    if (this.otelSdk) {
+      await this.otelSdk.shutdown();
+    }
+  }
+  /**
+   * Start a new span
+   */
+  startSpan(name, options) {
+    const span = {
+      name,
+      traceId: options?.parentSpan?.traceId ?? generateTraceId(),
+      spanId: generateSpanId(),
+      parentSpanId: options?.parentSpan?.spanId,
+      startTime: Date.now(),
+      attributes: options?.attributes ?? {},
+      status: "unset",
+      events: []
+    };
+    activeSpan = span;
+    this.spans.push(span);
+    return span;
+  }
+  /**
+   * End a span
+   */
+  endSpan(span, status = "ok") {
+    span.endTime = Date.now();
+    span.status = status;
+    if (activeSpan === span) {
+      activeSpan = null;
+    }
+  }
+  /**
+   * Add an event to a span
+   */
+  addEvent(span, name, attributes) {
+    span.events.push({
+      name,
+      timestamp: Date.now(),
+      attributes
+    });
+  }
+  /**
+   * Set span attribute
+   */
+  setAttribute(span, key, value) {
+    span.attributes[key] = value;
+  }
+  /**
+   * Get the currently active span
+   */
+  getActiveSpan() {
+    return activeSpan;
+  }
+  /**
+   * Extract trace context from headers
+   */
+  extractContext(headers) {
+    const traceparent = headers.get("traceparent");
+    if (!traceparent) return null;
+    const parts = traceparent.split("-");
+    if (parts.length !== 4) return null;
+    return {
+      traceId: parts[1] ?? "",
+      spanId: parts[2] ?? "",
+      traceFlags: Number.parseInt(parts[3] ?? "0", 16)
+    };
+  }
+  /**
+   * Inject trace context into headers
+   */
+  injectContext(headers, span) {
+    const traceparent = `00-${span.traceId}-${span.spanId}-01`;
+    headers.set("traceparent", traceparent);
+  }
+  /**
+   * Get all collected spans (for debugging)
+   */
+  getSpans() {
+    return this.spans;
+  }
+  /**
+   * Clear collected spans
+   */
+  clearSpans() {
+    this.spans = [];
+  }
+};
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/tracing/index.ts
+function createTracingMiddleware(tracer) {
+  return async (c, next) => {
+    const method = c.req.method;
+    const path = c.req.path;
+    const url = c.req.url;
+    const parentContext = tracer.extractContext(c.req.raw.headers);
+    const span = tracer.startSpan(`${method} ${path}`, {
+      attributes: {
+        "http.method": method,
+        "http.url": url,
+        "http.target": path,
+        "http.host": new URL(url).host
+      },
+      ...parentContext ? {
+        parentSpan: {
+          name: "parent",
+          traceId: parentContext.traceId,
+          spanId: parentContext.spanId,
+          startTime: Date.now(),
+          attributes: {},
+          status: "unset",
+          events: []
+        }
+      } : {}
+    });
+    c.set("span", span);
+    try {
+      await next();
+      tracer.endSpan(span, "ok");
+    } catch (error) {
+      tracer.setAttribute(span, "error", true);
+      tracer.setAttribute(
+        span,
+        "error.message",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      tracer.addEvent(span, "exception", {
+        "exception.type": error instanceof Error ? error.constructor.name : "Error",
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
+      tracer.endSpan(span, "error");
+      throw error;
+    }
+    return void 0;
+  };
+}
+
+// src/MonitorOrbit.ts
+var DEFAULTS4 = {
+  health: {
+    enabled: true,
+    path: "/health",
+    readyPath: "/ready",
+    livePath: "/live"
+  },
+  metrics: {
+    enabled: true,
+    path: "/metrics"
+  },
+  tracing: {
+    enabled: false
+  }
+};
+var MonitorOrbit = class {
+  name = "monitor";
+  userConfig;
+  healthRegistry = null;
+  metricsRegistry = null;
+  tracingManager = null;
+  constructor(config = {}) {
+    this.userConfig = config;
+  }
+  /**
+   * Install the orbit (required by GravitoOrbit interface)
+   */
+  async install(core) {
+    const healthEnabled = this.userConfig.health?.enabled !== void 0 ? this.userConfig.health.enabled : DEFAULTS4.health.enabled;
+    const metricsEnabled = this.userConfig.metrics?.enabled !== void 0 ? this.userConfig.metrics.enabled : DEFAULTS4.metrics.enabled;
+    const tracingEnabled = this.userConfig.tracing?.enabled !== void 0 ? this.userConfig.tracing.enabled : DEFAULTS4.tracing.enabled;
+    const healthPath = this.userConfig.health?.path || DEFAULTS4.health.path;
+    const readyPath = this.userConfig.health?.readyPath || DEFAULTS4.health.readyPath;
+    const livePath = this.userConfig.health?.livePath || DEFAULTS4.health.livePath;
+    const metricsPath = this.userConfig.metrics?.path || DEFAULTS4.metrics.path;
+    this.healthRegistry = new HealthRegistry(this.userConfig.health);
+    this.metricsRegistry = new MetricsRegistry(this.userConfig.metrics);
+    this.tracingManager = new TracingManager(this.userConfig.tracing);
+    if (tracingEnabled) {
+      await this.tracingManager.initialize();
+    }
+    const monitorService = {
+      health: this.healthRegistry,
+      metrics: this.metricsRegistry,
+      tracing: this.tracingManager
+    };
+    core.services.set("monitor", monitorService);
+    core.services.set("health", this.healthRegistry);
+    core.services.set("metrics", this.metricsRegistry);
+    core.services.set("tracing", this.tracingManager);
+    const router = core.router;
+    if (healthEnabled && this.healthRegistry) {
+      const healthController = new HealthController(this.healthRegistry);
+      router.get(healthPath, (c) => healthController.health(c));
+      router.get(readyPath, (c) => healthController.ready(c));
+      router.get(livePath, (c) => healthController.live(c));
+      console.log(`[Monitor] Health endpoints: ${healthPath}, ${readyPath}, ${livePath}`);
+    }
+    if (metricsEnabled && this.metricsRegistry) {
+      const metricsController = new MetricsController(this.metricsRegistry);
+      router.get(metricsPath, (c) => metricsController.metrics(c));
+      console.log(`[Monitor] Metrics endpoint: ${metricsPath}`);
+    }
+    console.log("[Monitor] Observability services initialized");
+  }
+  /**
+   * Shutdown hook
+   */
+  async shutdown() {
+    if (this.tracingManager) {
+      await this.tracingManager.shutdown();
+    }
+  }
+};
+export {
+  Counter,
+  Gauge,
+  HealthController,
+  HealthRegistry,
+  Histogram,
+  MetricsController,
+  MetricsRegistry,
+  MonitorOrbit,
+  TracingManager,
+  createDatabaseCheck,
+  createDiskCheck,
+  createHttpCheck,
+  createHttpMetricsMiddleware,
+  createMemoryCheck,
+  createRedisCheck,
+  createTracingMiddleware,
+  defineMonitorConfig
+};