@reactionary/core 0.0.28 → 0.0.30

package/index.js

@@ -54,12 +54,244 @@ function buildClient(providers) {
   return client;
 }
 
+// otel/src/trpc-middleware.ts
+import { TRPCError } from "@trpc/server";
+import {
+  SpanKind as SpanKind2,
+  SpanStatusCode as SpanStatusCode3
+} from "@opentelemetry/api";
+
+// otel/src/tracer.ts
+import {
+  trace,
+  SpanStatusCode,
+  context as otelContext
+} from "@opentelemetry/api";
+
+// otel/src/sdk.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+var sdk = null;
+var isInitialized = false;
+var initializationPromise = null;
+function isBrowser() {
+  return typeof window !== "undefined" && typeof process === "undefined";
+}
+function ensureInitialized() {
+  if (isInitialized || initializationPromise) {
+    return;
+  }
+  if (isBrowser()) {
+    isInitialized = true;
+    return;
+  }
+  initializationPromise = Promise.resolve().then(() => {
+    sdk = new NodeSDK();
+    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 { 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/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
+      );
+    }
+  };
+}
+
 // 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 +313,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.30",
   "dependencies": {
     "zod": "4.0.0-beta.20250430T185432",
-    "@upstash/redis": "^1.34.9"
+    "@upstash/redis": "^1.34.9",
+    "@reactionary/otel": "0.0.30"
   }
 }

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