@reactionary/core 0.0.28 → 0.0.29

package/index.js

@@ -54,12 +54,402 @@ function buildClient(providers) {
   return client;
 }
 
+// otel/src/sdk.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { resourceFromAttributes, defaultResource } from "@opentelemetry/resources";
+import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION, SEMRESATTRS_DEPLOYMENT_ENVIRONMENT } from "@opentelemetry/semantic-conventions";
+import {
+  BatchSpanProcessor
+} from "@opentelemetry/sdk-trace-base";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+
+// otel/src/config.ts
+import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { PeriodicExportingMetricReader, ConsoleMetricExporter } from "@opentelemetry/sdk-metrics";
+function isBrowser() {
+  return typeof window !== "undefined" && typeof process === "undefined";
+}
+function getConfigFromEnv() {
+  if (isBrowser()) {
+    return {
+      serviceName: "browser-service",
+      serviceVersion: void 0,
+      environment: "browser",
+      otlpEndpoint: void 0,
+      otlpHeaders: void 0,
+      traceEnabled: false,
+      metricsEnabled: false,
+      metricExportIntervalMillis: 6e4
+    };
+  }
+  const tracesExporter = process.env["OTEL_TRACES_EXPORTER"] || "console";
+  const metricsExporter = process.env["OTEL_METRICS_EXPORTER"] || "console";
+  return {
+    serviceName: process.env["OTEL_SERVICE_NAME"] || "unknown_service",
+    serviceVersion: process.env["OTEL_SERVICE_VERSION"],
+    environment: process.env["DEPLOYMENT_ENVIRONMENT"] || process.env["NODE_ENV"] || "development",
+    otlpEndpoint: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"],
+    otlpHeaders: process.env["OTEL_EXPORTER_OTLP_HEADERS"] ? parseHeaders(process.env["OTEL_EXPORTER_OTLP_HEADERS"]) : void 0,
+    traceEnabled: tracesExporter !== "none",
+    metricsEnabled: metricsExporter !== "none",
+    metricExportIntervalMillis: process.env["OTEL_METRIC_EXPORT_INTERVAL"] ? parseInt(process.env["OTEL_METRIC_EXPORT_INTERVAL"], 10) : 6e4
+    // Default 60 seconds per OTEL spec
+  };
+}
+function parseHeaders(headerString) {
+  const headers = {};
+  headerString.split(",").forEach((header) => {
+    const [key, value] = header.split("=");
+    if (key && value) {
+      headers[key.trim()] = value.trim();
+    }
+  });
+  return headers;
+}
+function createTraceExporter(config) {
+  if (!config.traceEnabled) {
+    return void 0;
+  }
+  const tracesExporter = process.env["OTEL_TRACES_EXPORTER"] || "console";
+  switch (tracesExporter) {
+    case "otlp":
+    case "otlp/http": {
+      if (!config.otlpEndpoint) {
+        console.warn("OTEL_EXPORTER_OTLP_ENDPOINT not set, falling back to console");
+        return new ConsoleSpanExporter();
+      }
+      const tracesEndpoint = process.env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] || `${config.otlpEndpoint}/v1/traces`;
+      return new OTLPTraceExporter({
+        url: tracesEndpoint,
+        headers: config.otlpHeaders
+      });
+    }
+    case "console":
+      return new ConsoleSpanExporter();
+    case "none":
+    default:
+      return void 0;
+  }
+}
+function createMetricReader(config) {
+  if (!config.metricsEnabled) {
+    return void 0;
+  }
+  const metricsExporter = process.env["OTEL_METRICS_EXPORTER"] || "console";
+  let exporter;
+  switch (metricsExporter) {
+    case "otlp":
+    case "otlp/http": {
+      if (!config.otlpEndpoint) {
+        console.warn("OTEL_EXPORTER_OTLP_ENDPOINT not set, falling back to console");
+        exporter = new ConsoleMetricExporter();
+      } else {
+        const metricsEndpoint = process.env["OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"] || `${config.otlpEndpoint}/v1/metrics`;
+        exporter = new OTLPMetricExporter({
+          url: metricsEndpoint,
+          headers: config.otlpHeaders
+        });
+      }
+      break;
+    }
+    case "console":
+      exporter = new ConsoleMetricExporter();
+      break;
+    case "none":
+    default:
+      return void 0;
+  }
+  return new PeriodicExportingMetricReader({
+    exporter,
+    exportIntervalMillis: config.metricExportIntervalMillis
+  });
+}
+
+// otel/src/sdk.ts
+var sdk = null;
+var isInitialized = false;
+var initializationPromise = null;
+function isBrowser2() {
+  return typeof window !== "undefined" && typeof process === "undefined";
+}
+function ensureInitialized() {
+  if (isInitialized || initializationPromise) {
+    return;
+  }
+  if (isBrowser2()) {
+    isInitialized = true;
+    return;
+  }
+  initializationPromise = Promise.resolve().then(() => {
+    const config = getConfigFromEnv();
+    if (process.env["OTEL_LOG_LEVEL"] === "debug") {
+      console.log("OpenTelemetry auto-initializing with config:", {
+        serviceName: config.serviceName,
+        environment: config.environment,
+        tracesExporter: process.env["OTEL_TRACES_EXPORTER"] || "console",
+        metricsExporter: process.env["OTEL_METRICS_EXPORTER"] || "console"
+      });
+    }
+    const attributes = {
+      [SEMRESATTRS_SERVICE_NAME]: config.serviceName
+    };
+    if (config.serviceVersion) {
+      attributes[SEMRESATTRS_SERVICE_VERSION] = config.serviceVersion;
+    }
+    if (config.environment) {
+      attributes[SEMRESATTRS_DEPLOYMENT_ENVIRONMENT] = config.environment;
+    }
+    const customResource = resourceFromAttributes(attributes);
+    const resource = defaultResource().merge(customResource);
+    const traceExporter = createTraceExporter(config);
+    const metricReader = createMetricReader(config);
+    const instrumentations = [
+      new HttpInstrumentation({
+        requestHook: (span, request) => {
+          const req = request;
+          if (req.headers) {
+            span.setAttribute("http.request.body.size", req.headers["content-length"] || 0);
+          }
+        },
+        responseHook: (span, response) => {
+          const res = response;
+          if (res.headers) {
+            span.setAttribute("http.response.body.size", res.headers["content-length"] || 0);
+          }
+        }
+      }),
+      new ExpressInstrumentation()
+    ];
+    sdk = new NodeSDK({
+      resource,
+      spanProcessors: traceExporter ? [new BatchSpanProcessor(traceExporter)] : [],
+      metricReader,
+      instrumentations
+    });
+    sdk.start();
+    isInitialized = true;
+    process.on("SIGTERM", async () => {
+      try {
+        await shutdownOtel();
+        if (process.env["OTEL_LOG_LEVEL"] === "debug") {
+          console.log("OpenTelemetry terminated successfully");
+        }
+      } catch (error) {
+        console.error("Error terminating OpenTelemetry", error);
+      }
+    });
+  });
+}
+async function shutdownOtel() {
+  if (sdk) {
+    await sdk.shutdown();
+    sdk = null;
+    isInitialized = false;
+  }
+}
+function isOtelInitialized() {
+  ensureInitialized();
+  return isInitialized;
+}
+
+// otel/src/tracer.ts
+import {
+  trace,
+  SpanStatusCode,
+  context as otelContext
+} from "@opentelemetry/api";
+import { SpanKind, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+var TRACER_NAME = "@reactionary/otel";
+var TRACER_VERSION = "0.0.1";
+var globalTracer = null;
+function getTracer() {
+  if (!globalTracer) {
+    isOtelInitialized();
+    globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
+  }
+  return globalTracer;
+}
+function withSpan(name, fn, options) {
+  const tracer = getTracer();
+  return tracer.startActiveSpan(name, options || {}, async (span) => {
+    try {
+      const result = await fn(span);
+      span.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      if (error instanceof Error) {
+        span.recordException(error);
+      }
+      throw error;
+    } finally {
+      span.end();
+    }
+  });
+}
+function setSpanAttributes(span, attributes) {
+  Object.entries(attributes).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      span.setAttribute(key, value);
+    }
+  });
+}
+
+// otel/src/metrics.ts
+import { metrics } from "@opentelemetry/api";
+var METER_NAME = "@reactionary/otel";
+var METER_VERSION = "0.0.1";
+var globalMeter = null;
+function getMeter() {
+  if (!globalMeter) {
+    isOtelInitialized();
+    globalMeter = metrics.getMeter(METER_NAME, METER_VERSION);
+  }
+  return globalMeter;
+}
+var metricsInstance = null;
+function initializeMetrics() {
+  if (metricsInstance) {
+    return metricsInstance;
+  }
+  const meter = getMeter();
+  metricsInstance = {
+    requestCounter: meter.createCounter("reactionary.requests", {
+      description: "Total number of requests"
+    }),
+    requestDuration: meter.createHistogram("reactionary.request.duration", {
+      description: "Request duration in milliseconds",
+      unit: "ms"
+    }),
+    activeRequests: meter.createUpDownCounter("reactionary.requests.active", {
+      description: "Number of active requests"
+    }),
+    errorCounter: meter.createCounter("reactionary.errors", {
+      description: "Total number of errors"
+    }),
+    providerCallCounter: meter.createCounter("reactionary.provider.calls", {
+      description: "Total number of provider calls"
+    }),
+    providerCallDuration: meter.createHistogram("reactionary.provider.duration", {
+      description: "Provider call duration in milliseconds",
+      unit: "ms"
+    }),
+    cacheHitCounter: meter.createCounter("reactionary.cache.hits", {
+      description: "Total number of cache hits"
+    }),
+    cacheMissCounter: meter.createCounter("reactionary.cache.misses", {
+      description: "Total number of cache misses"
+    })
+  };
+  return metricsInstance;
+}
+function getMetrics() {
+  if (!metricsInstance) {
+    return initializeMetrics();
+  }
+  return metricsInstance;
+}
+
+// otel/src/trpc-middleware.ts
+import { TRPCError } from "@trpc/server";
+import {
+  SpanKind as SpanKind2,
+  SpanStatusCode as SpanStatusCode3
+} from "@opentelemetry/api";
+
+// otel/src/provider-instrumentation.ts
+import { SpanKind as SpanKind3 } from "@opentelemetry/api";
+async function withProviderSpan(options, fn) {
+  const { providerName, operationType, operationName, attributes = {} } = options;
+  const metrics2 = getMetrics();
+  const spanName = `provider.${providerName}.${operationType}${operationName ? `.${operationName}` : ""}`;
+  const startTime = Date.now();
+  metrics2.providerCallCounter.add(1, {
+    "provider.name": providerName,
+    "provider.operation.type": operationType,
+    "provider.operation.name": operationName || "unknown"
+  });
+  return withSpan(
+    spanName,
+    async (span) => {
+      setSpanAttributes(span, {
+        "provider.name": providerName,
+        "provider.operation.type": operationType,
+        "provider.operation.name": operationName,
+        ...attributes
+      });
+      try {
+        const result = await fn(span);
+        const duration = Date.now() - startTime;
+        metrics2.providerCallDuration.record(duration, {
+          "provider.name": providerName,
+          "provider.operation.type": operationType,
+          "provider.operation.name": operationName || "unknown",
+          "status": "success"
+        });
+        return result;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        metrics2.providerCallDuration.record(duration, {
+          "provider.name": providerName,
+          "provider.operation.type": operationType,
+          "provider.operation.name": operationName || "unknown",
+          "status": "error"
+        });
+        metrics2.errorCounter.add(1, {
+          "provider.name": providerName,
+          "provider.operation.type": operationType,
+          "provider.operation.name": operationName || "unknown"
+        });
+        throw error;
+      }
+    },
+    { kind: SpanKind3.CLIENT }
+  );
+}
+function createProviderInstrumentation(providerName) {
+  return {
+    traceQuery: (operationName, fn, attributes) => {
+      return withProviderSpan(
+        {
+          providerName,
+          operationType: "query",
+          operationName,
+          attributes
+        },
+        fn
+      );
+    },
+    traceMutation: (operationName, fn, attributes) => {
+      return withProviderSpan(
+        {
+          providerName,
+          operationType: "mutation",
+          operationName,
+          attributes
+        },
+        fn
+      );
+    }
+  };
+}
+
+// otel/src/index.ts
+import { trace as trace2, context, SpanKind as SpanKind4, SpanStatusCode as SpanStatusCode4 } from "@opentelemetry/api";
+
 // core/src/providers/base.provider.ts
 var BaseProvider = class {
   constructor(schema, querySchema, mutationSchema) {
     this.schema = schema;
     this.querySchema = querySchema;
     this.mutationSchema = mutationSchema;
+    this.instrumentation = createProviderInstrumentation(this.constructor.name);
   }
   /**
    * Validates that the final domain model constructed by the provider
@@ -81,20 +471,35 @@ var BaseProvider = class {
    * of the results will match the order of the queries.
    */
   async query(queries, session) {
-    const results = await this.fetch(queries, session);
-    for (const result of results) {
-      this.assert(result);
-    }
-    return results;
+    return this.instrumentation.traceQuery(
+      "query",
+      async (span) => {
+        span.setAttribute("provider.query.count", queries.length);
+        const results = await this.fetch(queries, session);
+        for (const result of results) {
+          this.assert(result);
+        }
+        span.setAttribute("provider.result.count", results.length);
+        return results;
+      },
+      { queryCount: queries.length }
+    );
   }
   /**
    * Executes the listed mutations in order and returns the final state
    * resulting from that set of operations.
    */
   async mutate(mutations, session) {
-    const result = await this.process(mutations, session);
-    this.assert(result);
-    return result;
+    return this.instrumentation.traceMutation(
+      "mutate",
+      async (span) => {
+        span.setAttribute("provider.mutation.count", mutations.length);
+        const result = await this.process(mutations, session);
+        this.assert(result);
+        return result;
+      },
+      { mutationCount: mutations.length }
+    );
   }
 };
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@reactionary/core",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "dependencies": {
     "zod": "4.0.0-beta.20250430T185432",
-    "@upstash/redis": "^1.34.9"
+    "@upstash/redis": "^1.34.9",
+    "@reactionary/otel": "0.0.29"
   }
 }

package/src/providers/base.provider.d.ts

@@ -11,6 +11,7 @@ export declare abstract class BaseProvider<T extends BaseModel = BaseModel, Q ex
     readonly schema: z.ZodType<T>;
     readonly querySchema: z.ZodType<Q, Q>;
     readonly mutationSchema: z.ZodType<M, M>;
+    private instrumentation;
     constructor(schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
     /**
      * Validates that the final domain model constructed by the provider