service-bridge 1.0.9-dev.22 → 1.0.10-dev.23

package/dist/index.js

@@ -224,13 +224,70 @@ function normalizeServiceError(err, operation, component = "control-plane") {
     cause: err
   });
 }
+function friendlyGrpcMessage(code, rawMessage) {
+  switch (code) {
+    case grpc.status.UNAVAILABLE:
+      return "control plane unavailable";
+    case grpc.status.DEADLINE_EXCEEDED:
+      return "request timed out";
+    case grpc.status.UNAUTHENTICATED:
+      return "authentication failed — check service key";
+    case grpc.status.PERMISSION_DENIED:
+      return "permission denied — check service key";
+    case grpc.status.RESOURCE_EXHAUSTED:
+      return "rate limit exceeded";
+    case grpc.status.NOT_FOUND:
+      return "resource not found";
+    case grpc.status.INTERNAL:
+      return "internal server error";
+    case grpc.status.FAILED_PRECONDITION:
+      return "precondition failed";
+    case grpc.status.CANCELLED:
+      return "request cancelled";
+    case grpc.status.UNIMPLEMENTED:
+      return "operation not supported by control plane";
+    default:
+      return rawMessage || "unknown error";
+  }
+}
+function friendlySDKMessage(operation, err) {
+  const base = friendlyGrpcMessage(err.code, err.message);
+  switch (operation) {
+    case "open-worker-session":
+    case "worker-session":
+      return err.severity === "retriable" ? `${base} — waiting for reconnect` : `worker session error: ${base}`;
+    case "worker-session-end":
+      return `worker session cleanup: ${base}`;
+    case "worker-session-command":
+      return `worker command error: ${base}`;
+    case "heartbeat":
+      return `heartbeat failed: ${base}`;
+    case "http-heartbeat":
+      return `HTTP heartbeat failed: ${base}`;
+    case "flush-offline-queue":
+      return `offline queue flush failed: ${base}`;
+    case "flush-on-ready":
+    case "flush-on-restore":
+      return `log flush failed: ${base}`;
+    case "report-call-start":
+    case "report-call":
+      return `call report failed: ${base}`;
+    case "worker-force-shutdown":
+    case "worker-try-shutdown":
+      return `worker shutdown error: ${base}`;
+    case "close-control-plane-client":
+      return `control plane disconnect: ${base}`;
+    default:
+      return `${operation}: ${base}`;
+  }
+}
 function reportSDKError(operation, err, component = "sdk") {
   const normalized = normalizeServiceError(err, operation, component);
-  const message = `[servicebridge] ${normalized.component}.${normalized.operation}: ${normalized.message}`;
+  const friendly = friendlySDKMessage(operation, normalized);
   if (normalized.severity === "fatal") {
-    console.error(message, err);
+    console.error(`[servicebridge] ${friendly}`);
   } else {
-    console.warn(message, err);
+    console.warn(`[servicebridge] ${friendly}`);
   }
   return normalized;
 }
@@ -551,7 +608,30 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     md.add("x-caller-service", service);
     return md;
   }
+  function sessionSend(msg) {
+    if (!workerSessionStream)
+      return false;
+    try {
+      workerSessionStream.write(msg);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   async function sendReportCallStart(op) {
+    if (sessionSend({
+      telemetry_start: {
+        trace_id: op.traceId,
+        span_id: op.spanId,
+        parent_span_id: op.parentSpanId,
+        fn: op.fn,
+        started_at: String(op.startedAt),
+        input: op.inputBuf,
+        attempt: op.attempt
+      }
+    })) {
+      return;
+    }
     await new Promise((resolve, reject) => {
       stub.ReportCallStart({
         trace_id: op.traceId,
@@ -567,6 +647,22 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     });
   }
   async function sendReportCall(op) {
+    if (sessionSend({
+      telemetry_finish: {
+        trace_id: op.traceId,
+        span_id: op.spanId,
+        fn: op.fn,
+        started_at: String(op.startedAt),
+        duration_ms: String(op.durationMs),
+        success: op.success,
+        error: op.error ?? "",
+        input: op.inputBuf,
+        output: op.outputBuf ?? Buffer.alloc(0),
+        attempt: op.attempt
+      }
+    })) {
+      return;
+    }
     await new Promise((resolve, reject) => {
       stub.ReportCall({
         trace_id: op.traceId,
@@ -598,6 +694,8 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
       clearTimeout(logFlushTimer);
       logFlushTimer = null;
     }
+    if (sessionSend({ telemetry_log: { entries } }))
+      return;
     stub.ReportLog({ entries }, meta, unaryDeadlineOptions(), () => {});
   }
   function pushLog(level, msg, attrs) {
@@ -972,6 +1070,17 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
       return;
     const state = serveState;
     const metrics = getProcessMetrics();
+    const hbMsg = {
+      endpoint: state.endpoint,
+      group_names: [...registeredGroups],
+      function_names: [...fnHandlers.keys()]
+    };
+    if (metrics.cpuPercent != null)
+      hbMsg.cpu_percent = metrics.cpuPercent;
+    if (metrics.ramMb != null)
+      hbMsg.ram_mb = metrics.ramMb;
+    if (sessionSend({ heartbeat: hbMsg }))
+      return;
     const req = {
       service_name: service,
       instance_id: state.instanceId,
@@ -989,6 +1098,8 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     });
   }
   async function sendHttpHeartbeat(instanceId) {
+    if (sessionSend({ http_heartbeat: {} }))
+      return;
     await new Promise((resolve, reject) => {
       stub.HeartbeatHttpEndpoint({ service_name: service, instance_id: instanceId }, meta, unaryDeadlineOptions(), (err, res) => {
         if (err) {
@@ -1110,12 +1221,12 @@ function servicebridge(url, serviceKey, serviceOrOpts = {}, maybeGlobalOpts = {}
     const append = (data, key = "default") => {
       if (!isOnline || !runId)
         return Promise.resolve();
+      const dataBuf = Buffer.from(JSON.stringify(data));
+      if (sessionSend({ append_stream: { run_id: runId, key, data: dataBuf } })) {
+        return Promise.resolve();
+      }
       return new Promise((resolve, reject) => {
-        stub.AppendStream({
-          run_id: runId,
-          key,
-          data: Buffer.from(JSON.stringify(data))
-        }, meta, unaryDeadlineOptions(), (err) => err ? reject(normalizeServiceError(err, `append-stream:${runId}`)) : resolve());
+        stub.AppendStream({ run_id: runId, key, data: dataBuf }, meta, unaryDeadlineOptions(), (err) => err ? reject(normalizeServiceError(err, `append-stream:${runId}`)) : resolve());
       });
     };
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "service-bridge",
-  "version": "1.0.9-dev.22",
+  "version": "1.0.10-dev.23",
   "type": "module",
   "description": "ServiceBridge SDK for Node.js — production-ready RPC, durable events, workflows, jobs, and distributed tracing. One Go runtime + PostgreSQL replaces Istio, RabbitMQ, Temporal, and Jaeger.",
   "keywords": [