@reactionary/core 0.10.34 → 0.10.35

package/index.js

@@ -5,3 +5,4 @@ export * from "./factories/index.js";
 export * from "./capabilities/index.js";
 export * from "./schemas/index.js";
 export * from "./initialization.js";
+export * from "./metrics/protocol.js";

package/metrics/protocol.js

@@ -0,0 +1,84 @@
+import {
+  metrics,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+const METER_NAME = "@reactionary";
+const METER_VERSION = "0.0.1";
+let globalProtocolMetrics = null;
+function getReactionaryProtocolMeter() {
+  if (!globalProtocolMetrics) {
+    const meter = metrics.getMeter(METER_NAME, METER_VERSION);
+    globalProtocolMetrics = {
+      requests: meter.createCounter("reactionary_protocol_requests", {
+        description: "Counts the number of protocol invocations (UCP, ACP, MCP) served by Reactionary protocol servers"
+      }),
+      requestDuration: meter.createHistogram(
+        "reactionary_protocol_request_duration",
+        {
+          description: "Records the duration of protocol invocations (UCP, ACP, MCP) served by Reactionary protocol servers",
+          unit: "ms"
+        }
+      ),
+      requestsInProgress: meter.createUpDownCounter(
+        "reactionary_protocol_requests_in_progress",
+        {
+          description: "Tracks the number of in-progress protocol invocations (UCP, ACP, MCP)"
+        }
+      )
+    };
+  }
+  return globalProtocolMetrics;
+}
+async function traceProtocolInvocation(invocation, fn, getResultAttributes) {
+  const meter = getReactionaryProtocolMeter();
+  const tracer = trace.getTracer(METER_NAME, METER_VERSION);
+  const baseAttributes = {
+    "labels.protocol": invocation.protocol,
+    "labels.operation": invocation.operation,
+    ...invocation.attributes
+  };
+  const startTime = performance.now();
+  meter.requestsInProgress.add(1, baseAttributes);
+  return tracer.startActiveSpan(
+    `${invocation.protocol.toUpperCase()} ${invocation.operation}`,
+    { attributes: baseAttributes },
+    async (span) => {
+      let resultAttributes = { "labels.status": "success" };
+      try {
+        const result = await fn(span);
+        if (getResultAttributes) {
+          resultAttributes = { ...resultAttributes, ...getResultAttributes(result) };
+        }
+        if (resultAttributes["labels.status"] === "error") {
+          span.setStatus({ code: SpanStatusCode.ERROR });
+        }
+        span.setAttributes(resultAttributes);
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        resultAttributes = { "labels.status": "exception" };
+        span.recordException(err instanceof Error ? err : { message });
+        span.setStatus({ code: SpanStatusCode.ERROR, message });
+        throw err;
+      } finally {
+        const finalAttributes = { ...baseAttributes, ...resultAttributes };
+        meter.requestsInProgress.add(-1, baseAttributes);
+        meter.requests.add(1, finalAttributes);
+        meter.requestDuration.record(performance.now() - startTime, finalAttributes);
+        span.end();
+      }
+    }
+  );
+}
+function getHttpProtocolResultAttributes(response) {
+  return {
+    "labels.status": response.status >= 500 ? "error" : "success",
+    "http.response.status_code": response.status
+  };
+}
+export {
+  getHttpProtocolResultAttributes,
+  getReactionaryProtocolMeter,
+  traceProtocolInvocation
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.10.34",
+  "version": "0.10.35",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -5,4 +5,5 @@ export * from './factories/index.js';
 export * from './capabilities/index.js';
 export * from './schemas/index.js';
 export * from './initialization.js';
+export * from './metrics/protocol.js';
 export type { InferType } from './zod-utils.js';

package/src/metrics/protocol.d.ts

@@ -0,0 +1,20 @@
+import { type Attributes, type Counter, type Histogram, type Span, type UpDownCounter } from '@opentelemetry/api';
+export interface ReactionaryProtocolMetrics {
+    requests: Counter;
+    requestDuration: Histogram;
+    requestsInProgress: UpDownCounter;
+}
+export declare function getReactionaryProtocolMeter(): ReactionaryProtocolMetrics;
+export interface ReactionaryProtocolInvocation {
+    protocol: 'ucp' | 'acp' | 'mcp';
+    operation: string;
+    attributes?: Attributes;
+}
+/**
+ * Wraps a single protocol invocation (an inbound UCP/ACP HTTP request or an
+ * MCP tool call) in an OpenTelemetry span and records request count,
+ * duration, and in-progress metrics. `getResultAttributes` may add result
+ * attributes such as the HTTP status code and override `labels.status`.
+ */
+export declare function traceProtocolInvocation<T>(invocation: ReactionaryProtocolInvocation, fn: (span: Span) => Promise<T>, getResultAttributes?: (result: T) => Attributes): Promise<T>;
+export declare function getHttpProtocolResultAttributes(response: Response): Attributes;