Add support for logging in Edge Runtime

packages/telemetry/package.json

@@ -48,6 +48,8 @@
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/api-logs": "0.203.0",
     "@opentelemetry/exporter-logs-otlp-http": "0.203.0",
+    "@opentelemetry/otlp-exporter-base": "0.205.0",
+    "@opentelemetry/otlp-transformer": "0.205.0",
     "@opentelemetry/resources": "2.0.1",
     "@opentelemetry/sdk-logs": "0.203.0",
     "@opentelemetry/semantic-conventions": "1.36.0",

packages/telemetry/src/logging/fetch-transport.edge.test.ts

@@ -0,0 +1,177 @@
+/*
+ * @license
+ * Copyright The OpenTelemetry Authors
+ * Copyright 2025 Google LLC
+ *
+ * This file has been modified by Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as sinon from 'sinon';
+import * as assert from 'assert';
+import { FetchTransportEdge } from './fetch-transport.edge';
+import {
+  ExportResponseRetryable,
+  ExportResponseFailure,
+  ExportResponseSuccess
+} from '@opentelemetry/otlp-exporter-base';
+
+const testTransportParameters = {
+  url: 'http://example.test',
+  headers: () => ({
+    foo: 'foo-value',
+    bar: 'bar-value',
+    'Content-Type': 'application/json'
+  })
+};
+
+const requestTimeout = 1000;
+const testPayload = Uint8Array.from([1, 2, 3]);
+
+describe('FetchTransportEdge', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('send', () => {
+    it('returns success when request succeeds', done => {
+      // arrange
+      const fetchStub = sinon
+        .stub(globalThis, 'fetch')
+        .resolves(new Response('test response', { status: 200 }));
+      const transport = new FetchTransportEdge(testTransportParameters);
+
+      //act
+      transport.send(testPayload, requestTimeout).then(response => {
+        // assert
+        try {
+          assert.strictEqual(response.status, 'success');
+          // currently we don't do anything with the response yet, so it's dropped by the transport.
+          assert.strictEqual(
+            (response as ExportResponseSuccess).data,
+            undefined
+          );
+          sinon.assert.calledOnceWithMatch(
+            fetchStub,
+            testTransportParameters.url,
+            {
+              method: 'POST',
+              headers: {
+                foo: 'foo-value',
+                bar: 'bar-value',
+                'Content-Type': 'application/json'
+              },
+              body: testPayload
+            }
+          );
+          done();
+        } catch (e) {
+          done(e);
+        }
+      }, done /* catch any rejections */);
+    });
+
+    it('returns failure when request fails', done => {
+      // arrange
+      sinon
+        .stub(globalThis, 'fetch')
+        .resolves(new Response('', { status: 404 }));
+      const transport = new FetchTransportEdge(testTransportParameters);
+
+      //act
+      transport.send(testPayload, requestTimeout).then(response => {
+        // assert
+        try {
+          assert.strictEqual(response.status, 'failure');
+          done();
+        } catch (e) {
+          done(e);
+        }
+      }, done /* catch any rejections */);
+    });
+
+    it('returns retryable when request is retryable', done => {
+      // arrange
+      sinon
+        .stub(globalThis, 'fetch')
+        .resolves(
+          new Response('', { status: 503, headers: { 'Retry-After': '5' } })
+        );
+      const transport = new FetchTransportEdge(testTransportParameters);
+
+      //act
+      transport.send(testPayload, requestTimeout).then(response => {
+        // assert
+        try {
+          assert.strictEqual(response.status, 'retryable');
+          assert.strictEqual(
+            (response as ExportResponseRetryable).retryInMillis,
+            5000
+          );
+          done();
+        } catch (e) {
+          done(e);
+        }
+      }, done /* catch any rejections */);
+    });
+
+    it('returns failure when request times out', done => {
+      // arrange
+      const abortError = new Error('aborted request');
+      abortError.name = 'AbortError';
+      sinon.stub(globalThis, 'fetch').rejects(abortError);
+      const clock = sinon.useFakeTimers();
+      const transport = new FetchTransportEdge(testTransportParameters);
+
+      //act
+      transport.send(testPayload, requestTimeout).then(response => {
+        // assert
+        try {
+          assert.strictEqual(response.status, 'failure');
+          assert.strictEqual(
+            (response as ExportResponseFailure).error.message,
+            'aborted request'
+          );
+          done();
+        } catch (e) {
+          done(e);
+        }
+      }, done /* catch any rejections */);
+      clock.tick(requestTimeout + 100);
+    });
+
+    it('returns failure when no server exists', done => {
+      // arrange
+      sinon.stub(globalThis, 'fetch').throws(new Error('fetch failed'));
+      const clock = sinon.useFakeTimers();
+      const transport = new FetchTransportEdge(testTransportParameters);
+
+      //act
+      transport.send(testPayload, requestTimeout).then(response => {
+        // assert
+        try {
+          assert.strictEqual(response.status, 'failure');
+          assert.strictEqual(
+            (response as ExportResponseFailure).error.message,
+            'fetch failed'
+          );
+          done();
+        } catch (e) {
+          done(e);
+        }
+      }, done /* catch any rejections */);
+      clock.tick(requestTimeout + 100);
+    });
+  });
+});

packages/telemetry/src/logging/fetch-transport.edge.ts

@@ -0,0 +1,109 @@
+/*
+ * @license
+ * Copyright The OpenTelemetry Authors
+ * Copyright 2025 Google LLC
+ *
+ * This file has been modified by Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  IExporterTransport,
+  ExportResponse
+} from '@opentelemetry/otlp-exporter-base';
+import { diag } from '@opentelemetry/api';
+
+function isExportRetryable(statusCode: number): boolean {
+  const retryCodes = [429, 502, 503, 504];
+  return retryCodes.includes(statusCode);
+}
+
+function parseRetryAfterToMills(
+  retryAfter?: string | undefined | null
+): number | undefined {
+  if (retryAfter == null) {
+    return undefined;
+  }
+
+  const seconds = Number.parseInt(retryAfter, 10);
+  if (Number.isInteger(seconds)) {
+    return seconds > 0 ? seconds * 1000 : -1;
+  }
+  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After#directives
+  const delay = new Date(retryAfter).getTime() - Date.now();
+
+  if (delay >= 0) {
+    return delay;
+  }
+  return 0;
+}
+
+/** @internal */
+export interface FetchTransportParameters {
+  url: string;
+  headers: () => Record<string, string>;
+}
+
+/**
+ * An implementation of IExporterTransport that can be used in the Edge Runtime.
+ *
+ * @internal
+ */
+export class FetchTransportEdge implements IExporterTransport {
+  constructor(private parameters: FetchTransportParameters) {}
+
+  async send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse> {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), timeoutMillis);
+    try {
+      const url = new URL(this.parameters.url);
+      const body = {
+        method: 'POST',
+        headers: this.parameters.headers(),
+        signal: abortController.signal,
+        keepalive: false,
+        mode: 'cors',
+        body: data
+      } as RequestInit;
+      const response = await fetch(url.href, body);
+
+      if (response.status >= 200 && response.status <= 299) {
+        diag.debug('response success');
+        return { status: 'success' };
+      } else if (isExportRetryable(response.status)) {
+        const retryAfter = response.headers.get('Retry-After');
+        const retryInMillis = parseRetryAfterToMills(retryAfter);
+        return { status: 'retryable', retryInMillis };
+      }
+      return {
+        status: 'failure',
+        error: new Error('Fetch request failed with non-retryable status')
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        return { status: 'failure', error };
+      }
+      return {
+        status: 'failure',
+        error: new Error(`Fetch request errored: ${error}`)
+      };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  shutdown(): void {
+    // Intentionally left empty, nothing to do.
+  }
+}