@dronedeploy/rocos-js-sdk 3.1.0 → 3.1.2

package/cjs/api/streams/telemetry/FetchInjectingGrpcWebTransport.d.ts

@@ -0,0 +1,28 @@
+import { GrpcWebFetchTransport, GrpcWebOptions } from '@protobuf-ts/grpcweb-transport';
+import type { MethodInfo, RpcOptions, ServerStreamingCall, UnaryCall } from '@protobuf-ts/runtime-rpc';
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+export declare class FetchInjectingGrpcWebTransport extends GrpcWebFetchTransport {
+    private readonly customFetch;
+    constructor(customFetch: typeof globalThis.fetch | undefined, options: GrpcWebOptions);
+    private withFetch;
+    unary<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): UnaryCall<I, O>;
+    serverStreaming<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): ServerStreamingCall<I, O>;
+}

package/cjs/api/streams/telemetry/FetchInjectingGrpcWebTransport.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInjectingGrpcWebTransport = void 0;
+const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+class FetchInjectingGrpcWebTransport extends grpcweb_transport_1.GrpcWebFetchTransport {
+    constructor(customFetch, options) {
+        super(options);
+        this.customFetch = customFetch;
+    }
+    withFetch(start) {
+        if (!this.customFetch) {
+            return start();
+        }
+        const original = globalThis.fetch;
+        globalThis.fetch = this.customFetch;
+        try {
+            return start();
+        }
+        finally {
+            globalThis.fetch = original;
+        }
+    }
+    unary(method, input, options) {
+        return this.withFetch(() => super.unary(method, input, options));
+    }
+    serverStreaming(method, input, options) {
+        return this.withFetch(() => super.serverStreaming(method, input, options));
+    }
+}
+exports.FetchInjectingGrpcWebTransport = FetchInjectingGrpcWebTransport;

package/cjs/api/streams/telemetry/TelemetryStream.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryStream = void 0;
 const models_1 = require("../../../models");
 const teletubby_pb_1 = require("../../../grpc/teletubby_pb");
-const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+const FetchInjectingGrpcWebTransport_1 = require("./FetchInjectingGrpcWebTransport");
 const RocosLogger_1 = require("../../../logger/RocosLogger");
 const teletubby_pb_client_1 = require("../../../grpc/teletubby_pb.client");
 const TelemetryStreamAbstract_1 = require("./TelemetryStreamAbstract");
@@ -13,7 +13,11 @@ class TelemetryStream extends TelemetryStreamAbstract_1.TelemetryStreamAbstract
         this.logger = RocosLogger_1.RocosLogger.getInstance(`TelemetryStreamWeb(${this.identifier})`);
         const protocol = config.insecure ? 'http' : 'https';
         const port = config.port ? `:${config.port}` : '';
-        const transport = new grpcweb_transport_1.GrpcWebFetchTransport({
+        // Optional caller-supplied fetch (e.g. captured before Datadog RUM patches window.fetch, whose
+        // response cloning otherwise stalls this long-lived stream). When omitted, the transport uses
+        // the global fetch. @protobuf-ts/grpcweb-transport has no fetch option, so the injection happens
+        // in FetchInjectingGrpcWebTransport.
+        const transport = new FetchInjectingGrpcWebTransport_1.FetchInjectingGrpcWebTransport(config.fetch, {
             baseUrl: `${protocol}://${this.url}${port}`,
             format: config.grpcWebFormat,
         });

package/cjs/api/streams/telemetry/TelemetryStreamConnect.js

@@ -30,6 +30,12 @@ class TelemetryStreamConnect extends TelemetryStreamAbstract_1.TelemetryStreamAb
             // payloads containing control characters (verified against a live robot on dev) and is
             // less efficient. Binary is required for correctness here.
             useBinaryFormat: true,
+            // Optional caller-supplied fetch. Pass a reference captured before page-level instrumentation
+            // (e.g. Datadog RUM) monkey-patches `window.fetch`: RUM clones and reads every fetch response
+            // to measure timing, and on this long-lived server-stream that clone-read stalls connect-web's
+            // read (stream connects 200 but yields no frames). When omitted, connect-web uses the global
+            // fetch. See docs/connect-rpc-investigation.md.
+            ...(config.fetch ? { fetch: config.fetch } : {}),
         });
         this.client = (0, connect_1.createClient)(teletubby_pb_1.TelemetryGateway, transport);
     }

package/cjs/models/IRocosSDKConfig.d.ts

@@ -12,6 +12,7 @@ interface ConfigBase {
     port?: number;
     insecure?: boolean;
     transport?: TelemetryTransport;
+    fetch?: typeof globalThis.fetch;
     hooks?: {
         http?: {
             onResponse?: (res: Response) => void;

package/cjs/models/IStreamConfig.d.ts

@@ -9,4 +9,5 @@ export interface IStreamConfig {
     insecure?: boolean;
     transport?: TelemetryTransport;
     grpcWebFormat?: 'text' | 'binary';
+    fetch?: typeof globalThis.fetch;
 }

package/cjs/services/TelemetryService.js

@@ -164,6 +164,7 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
             port: this.config.port,
             insecure: this.config.insecure,
             transport: this.config.transport,
+            fetch: this.config.fetch,
         });
         if (!newStream.isNew) {
             newStream.stream.statusStream$.subscribe((msg) => {

package/esm/api/streams/telemetry/FetchInjectingGrpcWebTransport.d.ts

@@ -0,0 +1,28 @@
+import { GrpcWebFetchTransport, GrpcWebOptions } from '@protobuf-ts/grpcweb-transport';
+import type { MethodInfo, RpcOptions, ServerStreamingCall, UnaryCall } from '@protobuf-ts/runtime-rpc';
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+export declare class FetchInjectingGrpcWebTransport extends GrpcWebFetchTransport {
+    private readonly customFetch;
+    constructor(customFetch: typeof globalThis.fetch | undefined, options: GrpcWebOptions);
+    private withFetch;
+    unary<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): UnaryCall<I, O>;
+    serverStreaming<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): ServerStreamingCall<I, O>;
+}

package/esm/api/streams/telemetry/FetchInjectingGrpcWebTransport.js

@@ -0,0 +1,45 @@
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+export class FetchInjectingGrpcWebTransport extends GrpcWebFetchTransport {
+    constructor(customFetch, options) {
+        super(options);
+        this.customFetch = customFetch;
+    }
+    withFetch(start) {
+        if (!this.customFetch) {
+            return start();
+        }
+        const original = globalThis.fetch;
+        globalThis.fetch = this.customFetch;
+        try {
+            return start();
+        }
+        finally {
+            globalThis.fetch = original;
+        }
+    }
+    unary(method, input, options) {
+        return this.withFetch(() => super.unary(method, input, options));
+    }
+    serverStreaming(method, input, options) {
+        return this.withFetch(() => super.serverStreaming(method, input, options));
+    }
+}

package/esm/api/streams/telemetry/TelemetryStream.js

@@ -1,6 +1,6 @@
 import { SubscriberStatusEnum } from '../../../models';
 import { RegistrationMessage, } from '../../../grpc/teletubby_pb';
-import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { FetchInjectingGrpcWebTransport } from './FetchInjectingGrpcWebTransport';
 import { RocosLogger } from '../../../logger/RocosLogger';
 import { TelemetryGatewayClient } from '../../../grpc/teletubby_pb.client';
 import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
@@ -10,7 +10,11 @@ export class TelemetryStream extends TelemetryStreamAbstract {
         this.logger = RocosLogger.getInstance(`TelemetryStreamWeb(${this.identifier})`);
         const protocol = config.insecure ? 'http' : 'https';
         const port = config.port ? `:${config.port}` : '';
-        const transport = new GrpcWebFetchTransport({
+        // Optional caller-supplied fetch (e.g. captured before Datadog RUM patches window.fetch, whose
+        // response cloning otherwise stalls this long-lived stream). When omitted, the transport uses
+        // the global fetch. @protobuf-ts/grpcweb-transport has no fetch option, so the injection happens
+        // in FetchInjectingGrpcWebTransport.
+        const transport = new FetchInjectingGrpcWebTransport(config.fetch, {
             baseUrl: `${protocol}://${this.url}${port}`,
             format: config.grpcWebFormat,
         });

package/esm/api/streams/telemetry/TelemetryStreamConnect.js

@@ -27,6 +27,12 @@ export class TelemetryStreamConnect extends TelemetryStreamAbstract {
             // payloads containing control characters (verified against a live robot on dev) and is
             // less efficient. Binary is required for correctness here.
             useBinaryFormat: true,
+            // Optional caller-supplied fetch. Pass a reference captured before page-level instrumentation
+            // (e.g. Datadog RUM) monkey-patches `window.fetch`: RUM clones and reads every fetch response
+            // to measure timing, and on this long-lived server-stream that clone-read stalls connect-web's
+            // read (stream connects 200 but yields no frames). When omitted, connect-web uses the global
+            // fetch. See docs/connect-rpc-investigation.md.
+            ...(config.fetch ? { fetch: config.fetch } : {}),
         });
         this.client = createClient(TelemetryGateway, transport);
     }

package/esm/models/IRocosSDKConfig.d.ts

@@ -12,6 +12,7 @@ interface ConfigBase {
     port?: number;
     insecure?: boolean;
     transport?: TelemetryTransport;
+    fetch?: typeof globalThis.fetch;
     hooks?: {
         http?: {
             onResponse?: (res: Response) => void;

package/esm/models/IStreamConfig.d.ts

@@ -9,4 +9,5 @@ export interface IStreamConfig {
     insecure?: boolean;
     transport?: TelemetryTransport;
     grpcWebFormat?: 'text' | 'binary';
+    fetch?: typeof globalThis.fetch;
 }

package/esm/services/TelemetryService.js

@@ -161,6 +161,7 @@ export class TelemetryService extends BaseStreamService {
             port: this.config.port,
             insecure: this.config.insecure,
             transport: this.config.transport,
+            fetch: this.config.fetch,
         });
         if (!newStream.isNew) {
             newStream.stream.statusStream$.subscribe((msg) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",