cabloy 5.1.219 → 5.1.220

package/vona/src/suite-vendor/a-vona/modules/a-logger/src/lib/redactHttpLog.test.ts

@@ -0,0 +1,207 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { registerHooks } from 'node:module';
+import { test } from 'node:test';
+import ts from 'typescript';
+
+import { redactHttpLogHeaders, redactHttpLogUrl } from './redactHttpLog.ts';
+
+const previousApp = Object.getOwnPropertyDescriptor(globalThis, '__app__');
+const vonaUrl = new URL('../../../../../../../', import.meta.url);
+const middlewareUrl = new URL(
+  '../bean/middlewareSystem.httpLog.ts?fixture=httpLogging',
+  import.meta.url,
+).href;
+const formatterUrl = new URL('packages-vona/vona-core/src/lib/core/logger/utils.ts', vonaUrl).href;
+const checkUrl = new URL('packages-utils/utils/src/check.ts', vonaUrl).href;
+const fixture = (source: string) => `data:text/javascript,${encodeURIComponent(source)}`;
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (context.parentURL === middlewareUrl) {
+      if (specifier === 'vona') {
+        return {
+          url: fixture('export class BeanBase {} export function getRequestBoundary() {}'),
+          shortCircuit: true,
+        };
+      }
+      if (specifier === 'vona-module-a-aspect') {
+        return {
+          url: fixture('export function MiddlewareSystem() { return () => {}; }'),
+          shortCircuit: true,
+        };
+      }
+    }
+    if (context.parentURL === formatterUrl) {
+      if (specifier === '@cabloy/utils') return { url: checkUrl, shortCircuit: true };
+      if (specifier === '../../framework/useApp.ts') {
+        return {
+          url: fixture(
+            'export function useApp() { throw new Error("unexpected application access"); }',
+          ),
+          shortCircuit: true,
+        };
+      }
+    }
+    return nextResolve(specifier, context);
+  },
+  load(url, context, nextLoad) {
+    if (url === middlewareUrl) {
+      return {
+        format: 'module',
+        source: ts.transpileModule(readFileSync(new URL(url), 'utf8'), {
+          compilerOptions: {
+            experimentalDecorators: true,
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.ESNext,
+          },
+        }).outputText,
+        shortCircuit: true,
+      };
+    }
+    return nextLoad(url, context);
+  },
+});
+const { MiddlewareSystemHttpLog, formatLoggerFilter } = await (async () => {
+  try {
+    return { ...(await import(middlewareUrl)), ...(await import(formatterUrl)) };
+  } finally {
+    hooks.deregister();
+  }
+})();
+
+const secret = 'synthetic-http-secret-sentinel';
+
+test('header copies hide standard, mixed-case and custom credentials', () => {
+  const headers = Object.freeze({
+    'Authorization': secret,
+    'Proxy-Authorization': secret,
+    'Cookie': secret,
+    'Set-Cookie': Object.freeze([secret, secret]),
+    'X-Custom-Credential': secret,
+    'Location': `/callback?code=${secret}`,
+    'Referer': `/callback?state=${secret}`,
+    'Content-Type': 'application/json',
+    'content-length': '42',
+    'accept': 'application/json',
+  });
+  const logged = redactHttpLogHeaders(headers);
+  assert.equal(JSON.stringify(logged).includes(secret), false);
+  assert.equal(logged['Content-Type'], 'application/json');
+  assert.equal(logged['content-length'], '42');
+  assert.equal(logged.accept, 'application/json');
+  assert.equal(headers.Authorization, secret);
+  assert.deepEqual(headers['Set-Cookie'], [secret, secret]);
+  assert.notEqual(logged, headers);
+});
+
+test('URL projections omit all query/fragment data and absolute-URL userinfo', () => {
+  for (const key of [
+    'access_token',
+    'refresh_token',
+    'code',
+    'state',
+    'x-vona-passport-code',
+    'custom',
+  ]) {
+    const url = `/callback?${key}=${secret}&${key}=${secret}#${secret}`;
+    assert.equal(redactHttpLogUrl(url), '/callback?[REDACTED]');
+  }
+  assert.equal(redactHttpLogUrl(`/callback#${secret}`), '/callback?[REDACTED]');
+  assert.equal(
+    redactHttpLogUrl(`https://${secret}:${secret}@example.invalid/callback?x=${secret}`),
+    'https://example.invalid/callback?[REDACTED]',
+  );
+  assert.equal(
+    redactHttpLogUrl(`//${secret}@example.invalid/callback`),
+    '//example.invalid/callback',
+  );
+  assert.equal(redactHttpLogUrl('https://['), '[REDACTED]');
+  assert.equal(redactHttpLogUrl(`data:${secret}`), '[REDACTED]');
+  assert.equal(redactHttpLogUrl({ path: secret }), undefined);
+  assert.equal(redactHttpLogUrl('/ordinary/path'), '/ordinary/path');
+  assert.equal(redactHttpLogUrl('*'), '*');
+});
+
+for (const failure of [false, true]) {
+  test(`actual middleware strict-http projection, downstream ${failure ? 'error' : 'success'}`, async () => {
+    const output: string[] = [];
+    const filter = formatLoggerFilter({ level: 'http', child: undefined, strict: true });
+    const capture = (message: any, extra = {}) => {
+      const info = filter.transform({ level: 'http', message, ...extra }, filter.options);
+      assert.ok(info);
+      output.push(JSON.stringify(info));
+    };
+    const headers = Object.freeze({
+      authorization: secret,
+      cookie: secret,
+      accept: 'application/json',
+    });
+    const responseHeaders = Object.freeze({
+      'set-cookie': [secret],
+      'content-type': 'application/json',
+    });
+    const req = Object.freeze({
+      method: 'POST',
+      url: `/callback?custom=${secret}`,
+      originalUrl: `/callback?x-vona-passport-code=${secret}`,
+      query: { custom: secret },
+      params: { token: secret },
+      body: { token: secret },
+      headers,
+      socket: { remoteAddress: '127.0.0.1', remotePort: 12345 },
+    });
+    const ctx = {
+      req,
+      path: '/callback',
+      res: { statusCode: 204, getHeaders: () => responseHeaders },
+    };
+    const fake = {
+      ctx,
+      app: { meta: { env: {} } },
+      $loggerChild: (name: string) => {
+        assert.ok(name === 'req' || name === 'res');
+        return {
+          http: (message: any) => capture(message),
+          startTimer: () => ({
+            done: (info: any) => {
+              assert.equal(info.level, 'http');
+              capture(info.message, { durationMs: 7 });
+            },
+          }),
+        };
+      },
+    };
+    let calls = 0;
+    const error = new Error(secret);
+    const execution = MiddlewareSystemHttpLog.prototype.execute.call(fake as any, {}, async () => {
+      calls++;
+      assert.equal(ctx.req, req);
+      assert.equal(ctx.req.headers.authorization, secret);
+      assert.equal(ctx.req.body.token, secret);
+      if (failure) throw error;
+    });
+    if (failure) {
+      await assert.rejects(execution, value => value === error);
+    } else {
+      await execution;
+    }
+    assert.equal(calls, 1);
+    assert.equal(output.length, failure ? 1 : 2);
+    assert.equal(output.join('\n').includes(secret), false);
+    const request = JSON.parse(JSON.parse(output[0]!).message);
+    assert.equal(request.method, 'POST');
+    assert.equal(request.url, '/callback?[REDACTED]');
+    assert.equal(request.query, undefined);
+    assert.equal(request.params, undefined);
+    assert.equal(request.body, undefined);
+    assert.equal(request.raw, undefined);
+    if (!failure) {
+      const response = JSON.parse(output[1]!);
+      assert.equal(response.durationMs, 7);
+      assert.equal(JSON.parse(response.message).statusCode, 204);
+    }
+    assert.equal(req.url, `/callback?custom=${secret}`);
+    assert.deepEqual(responseHeaders['set-cookie'], [secret]);
+    assert.deepEqual(Object.getOwnPropertyDescriptor(globalThis, '__app__'), previousApp);
+  });
+}

package/vona/src/suite-vendor/a-vona/modules/a-logger/src/lib/redactHttpLog.ts

@@ -0,0 +1,30 @@
+const safeHeaders = new Set(['accept', 'content-type', 'content-length']);
+
+export function redactHttpLogHeaders(headers: Record<string, unknown>): Record<string, unknown> {
+  // Allowlist diagnostic metadata so custom credential headers are covered too.
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      key,
+      safeHeaders.has(key.toLowerCase()) ? value : '[REDACTED]',
+    ]),
+  );
+}
+
+export function redactHttpLogUrl(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const boundary = value.search(/[?#]/);
+  let path = boundary < 0 ? value : value.slice(0, boundary);
+  if (/^[a-z][a-z\d+.-]*:\/\//i.test(path) || path.startsWith('//')) {
+    try {
+      const url = new URL(path, 'http://redacted.invalid');
+      if (url.protocol !== 'http:' && url.protocol !== 'https:') return '[REDACTED]';
+      path = `${path.startsWith('//') ? '//' : `${url.protocol}//`}${url.host}${url.pathname}`;
+    } catch {
+      return '[REDACTED]';
+    }
+  } else if (!path.startsWith('/') && path !== '*') {
+    return '[REDACTED]';
+  }
+  // Query names can be configured by authentication clients; omit the whole query/fragment.
+  return `${path}${boundary < 0 ? '' : '?[REDACTED]'}`;
+}

package/vona/src/suite-vendor/a-vona/modules/a-logger/test/middlewareSystem.httpLog.test.ts

@@ -8,11 +8,18 @@ const middlewareUrl = new URL(
   '../src/bean/middlewareSystem.httpLog.ts?fixture=httpLog',
   import.meta.url,
 ).href;
+const boundaryFixture = `data:text/javascript,${encodeURIComponent(`
+  export class BeanBase {}
+  let boundary;
+  export function getRequestBoundary() { return boundary; }
+  export function setBoundary(value) { boundary = value; }
+`)}`;
+const { setBoundary } = await import(boundaryFixture);
 const hooks = registerHooks({
   resolve(specifier, context, nextResolve) {
     if (context.parentURL === middlewareUrl) {
+      if (specifier === 'vona') return { url: boundaryFixture, shortCircuit: true };
       const source = {
-        'vona': 'export class BeanBase {}',
         'vona-module-a-aspect': 'export function MiddlewareSystem() { return () => {}; }',
         'pino-std-serializers':
           'export default { req: req => ({ headers: req.headers, url: req.url }) };',
@@ -42,6 +49,31 @@ const hooks = registerHooks({
 const { MiddlewareSystemHttpLog } = await import(middlewareUrl);
 hooks.deregister();
 
+test('HTTP logger skips context and diagnostic access inside a request boundary', async () => {
+  const middleware = Object.create(MiddlewareSystemHttpLog.prototype);
+  for (const key of ['app', 'ctx', '$loggerChild']) {
+    Object.defineProperty(middleware, key, {
+      get() {
+        assert.fail('protected diagnostic access');
+      },
+    });
+  }
+  let calls = 0;
+  setBoundary({ diagnostics: 'suppress' });
+  try {
+    assert.equal(
+      await middleware.execute({}, async () => {
+        calls++;
+        return 23;
+      }),
+      23,
+    );
+    assert.equal(calls, 1);
+  } finally {
+    setBoundary(undefined);
+  }
+});
+
 for (const path of ['/health/ready', '/health/test-stop']) {
   test(`HTTP logger redacts request authorization and response proof at ${path} without mutating headers`, async () => {
     const headers = {

package/vona/src/suite-vendor/a-vona/modules/a-startup/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-startup",
-  "version": "5.1.20",
+  "version": "5.1.21",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-startup/src/service/startup.ts

@@ -5,6 +5,8 @@ import { isNil } from '@cabloy/utils';
 import fse from 'fs-extra';
 import {
   assertIsolatedTestConfig,
+  assertFreshTestResourcesReady,
+  requiresFreshTestResources,
   BeanBase,
   cast,
   getRuntimePathPhysicalRoot,
@@ -242,6 +244,10 @@ export class ServiceStartup extends BeanBase {
   private async _clearResources() {
     if (!this.app.meta.isTest) return;
     assertIsolatedTestConfig(this.app);
+    if (requiresFreshTestResources()) {
+      assertFreshTestResourcesReady(this.app);
+      return;
+    }
     // redis
     await this.$scope.redis.service.redis.clearAllData();
     // .app/public

package/vona/src/suite-vendor/a-vona/modules/a-startup/test/devSeed.test.ts

@@ -217,7 +217,7 @@ describe('creation-driven dev seed', { concurrency: false }, () => {
     const { service, app, calls, pending } = fixture(['', 'isolateTest']);
     const runStartup = service.runStartup.bind(service);
     service.runStartup = async (name, instance, options) => {
-      if (name === 'a-version:instanceInit' && instance === 'isolateTest') {
+      if (name === 'a-version:instanceInit' && String(instance) === 'isolateTest') {
         throw new Error('isolate init failed');
       }
       await runStartup(name, instance, options);
@@ -239,7 +239,7 @@ describe('creation-driven dev seed', { concurrency: false }, () => {
       } else {
         const runStartup = service.runStartup.bind(service);
         service.runStartup = async (name, instance, options) => {
-          if (name === 'a-version:instanceInit' && instance === 'isolateTest') {
+          if (name === 'a-version:instanceInit' && String(instance) === 'isolateTest') {
             throw new Error('isolate init failed');
           }
           await runStartup(name, instance, options);

package/vona/src/suite-vendor/a-vona/modules/a-telemetry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-telemetry",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "",
   "keywords": [
     "Vona Module"

package/vona/src/suite-vendor/a-vona/modules/a-telemetry/src/bean/bean.telemetry.ts

@@ -1,7 +1,7 @@
 import type { Span, SpanOptions } from '@opentelemetry/api';
 
 import { INVALID_SPAN_CONTEXT, trace } from '@opentelemetry/api';
-import { BeanBase } from 'vona';
+import { BeanBase, getRequestBoundary } from 'vona';
 import { Bean } from 'vona-module-a-bean';
 
 const nonRecordingSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
@@ -9,25 +9,30 @@ const nonRecordingSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
 @Bean()
 export class BeanTelemetry extends BeanBase {
   get enabled() {
+    if (getRequestBoundary()) return false;
     return this.scope.service.telemetry.enabled;
   }
 
   startSpan(name: string, options?: SpanOptions): Span {
+    if (getRequestBoundary()) return nonRecordingSpan;
     const telemetry = this.scope.service.telemetry;
     return telemetry.enabled ? telemetry.startSpan(name, options) : nonRecordingSpan;
   }
 
   withSpan<RESULT>(span: Span, fn: () => RESULT): RESULT {
+    if (getRequestBoundary()) return fn();
     const telemetry = this.scope.service.telemetry;
     return telemetry.enabled ? telemetry.withSpan(span, fn) : fn();
   }
 
   recordException(span: Span, error: unknown) {
+    if (getRequestBoundary()) return;
     const telemetry = this.scope.service.telemetry;
     if (telemetry.enabled) telemetry.recordException(span, error);
   }
 
   withNamedSpan<RESULT>(name: string, fn: () => RESULT, options?: SpanOptions): RESULT {
+    if (getRequestBoundary()) return fn();
     const span = this.startSpan(name, options);
     try {
       const result = this.withSpan(span, fn);
@@ -52,6 +57,7 @@ export class BeanTelemetry extends BeanBase {
   }
 
   private _recordAndEndSpan(span: Span, error: unknown) {
+    if (getRequestBoundary()) return;
     try {
       this.recordException(span, error);
     } catch {}
@@ -59,6 +65,7 @@ export class BeanTelemetry extends BeanBase {
   }
 
   private _endSpan(span: Span) {
+    if (getRequestBoundary()) return;
     try {
       span.end();
     } catch {}

package/vona/src/suite-vendor/a-vona/modules/a-telemetry/src/bean/middlewareSystem.trace.ts

@@ -1,4 +1,3 @@
-import type { Span } from '@opentelemetry/api';
 import type { Next } from 'vona';
 import type {
   IDecoratorMiddlewareSystemOptions,
@@ -6,9 +5,11 @@ import type {
 } from 'vona-module-a-aspect';
 
 import { context } from '@opentelemetry/api';
-import { BeanBase, uuidv4 } from 'vona';
+import { BeanBase, captureRequestBoundary, getRequestBoundary, uuidv4 } from 'vona';
 import { MiddlewareSystem } from 'vona-module-a-aspect';
 
+import { createHttpSpanEnd, recordSpanException } from '../lib/spanDiagnostics.ts';
+
 export interface IMiddlewareSystemOptionsTrace extends IDecoratorMiddlewareSystemOptions {}
 
 @MiddlewareSystem<IMiddlewareSystemOptionsTrace>({
@@ -16,6 +17,7 @@ export interface IMiddlewareSystemOptionsTrace extends IDecoratorMiddlewareSyste
 })
 export class MiddlewareSystemTrace extends BeanBase implements IMiddlewareSystemExecute {
   async execute(_options: IMiddlewareSystemOptionsTrace, next: Next) {
+    if (getRequestBoundary()) return next();
     const telemetry = this.$scope.telemetry.service.telemetry;
     if (!telemetry.enabled || this.ctx.state.telemetry?.internalAction) return next();
 
@@ -37,11 +39,10 @@ export class MiddlewareSystemTrace extends BeanBase implements IMiddlewareSystem
     ctx.state.telemetry = { requestId, context: active, serverSpan: span };
     ctx.set(requestIdHeader, requestId);
 
-    const finish = () => this._end(span, ctx.res.statusCode || ctx.status || 500, false);
-    const close = () =>
-      this._end(span, ctx.res.statusCode || ctx.status || 499, !ctx.res.writableEnded);
-    ctx.res.once('finish', finish);
-    ctx.res.once('close', close);
+    const capture = captureRequestBoundary();
+    const terminal = createHttpSpanEnd(span, ctx.res, capture);
+    ctx.res.once('finish', terminal.finish);
+    ctx.res.once('close', terminal.close);
 
     try {
       const result = await context.with(active, next);
@@ -55,16 +56,10 @@ export class MiddlewareSystemTrace extends BeanBase implements IMiddlewareSystem
       }
       return result;
     } catch (err) {
-      telemetry.recordException(span, err);
+      recordSpanException(span, err, capture);
       throw err;
     }
   }
-
-  private _end(span: Span, statusCode: number, aborted: boolean) {
-    if (!span || this.ctx.state.telemetry?.serverSpanEnded) return;
-    this.ctx.state.telemetry!.serverSpanEnded = true;
-    this.$scope.telemetry.service.telemetry.endHttpSpan(span, statusCode, aborted);
-  }
 }
 
 function normalizeRequestId(value?: string) {

package/vona/src/suite-vendor/a-vona/modules/a-telemetry/src/lib/spanDiagnostics.ts

@@ -0,0 +1,70 @@
+import type { Span } from '@opentelemetry/api';
+import type { RequestBoundaryCapture } from 'vona';
+
+import { SpanStatusCode } from '@opentelemetry/api';
+import { captureRequestBoundary, getRequestBoundary } from 'vona';
+
+export interface HttpSpanResponse {
+  readonly statusCode: number;
+  readonly writableEnded: boolean;
+  removeListener: (event: 'finish' | 'close', listener: () => void) => unknown;
+}
+
+export function recordSpanException(
+  span: Span,
+  error: unknown,
+  capture?: RequestBoundaryCapture,
+): void {
+  if (capture || getRequestBoundary()) return;
+  if (error instanceof Error) {
+    span.recordException(error);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+    return;
+  }
+  span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+}
+
+export function endHttpSpan(span: Span, statusCode: number, aborted = false): void {
+  if (getRequestBoundary()) return;
+  if (aborted || statusCode >= 500) {
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: aborted ? 'client aborted' : undefined,
+    });
+  }
+  span.setAttribute('http.response.status_code', statusCode);
+  if (aborted) span.setAttribute('vona.http.aborted', true);
+  span.end();
+}
+
+export function createHttpSpanEnd(
+  span: Span,
+  response: HttpSpanResponse,
+  capture?: RequestBoundaryCapture,
+): Readonly<{ finish(): void; close(): void }> {
+  capture ??= captureRequestBoundary();
+  const reportFailure = () => capture?.reportFailure('late_callback_failed');
+  let ended = false;
+  const finish = () => end(false);
+  const close = () => end(true);
+  function end(closed: boolean) {
+    if (ended) return;
+    ended = true;
+    try {
+      response.removeListener(closed ? 'finish' : 'close', closed ? finish : close);
+    } catch {
+      reportFailure();
+    }
+    if (capture || getRequestBoundary()) return;
+    try {
+      endHttpSpan(
+        span,
+        response.statusCode || (closed ? 499 : 500),
+        closed && !response.writableEnded,
+      );
+    } catch {
+      reportFailure();
+    }
+  }
+  return Object.freeze({ finish, close });
+}

package/vona/src/suite-vendor/a-vona/modules/a-telemetry/src/service/telemetry.ts

@@ -1,6 +1,13 @@
 import type { Context, Span, SpanOptions } from '@opentelemetry/api';
 
-import { context, propagation, SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
+import {
+  context,
+  INVALID_SPAN_CONTEXT,
+  propagation,
+  ROOT_CONTEXT,
+  SpanKind,
+  trace,
+} from '@opentelemetry/api';
 import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
 import { W3CTraceContextPropagator } from '@opentelemetry/core';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
@@ -11,12 +18,15 @@ import {
   TraceIdRatioBasedSampler,
 } from '@opentelemetry/sdk-trace-base';
 import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
-import { BeanBase } from 'vona';
+import { BeanBase, captureRequestBoundary, getRequestBoundary } from 'vona';
 import { Service } from 'vona-module-a-bean';
 
 import type { ITelemetryCarrier } from '../types/telemetry.ts';
 
 import { createIngressTrustChecker } from '../lib/ingress.ts';
+import { endHttpSpan, recordSpanException } from '../lib/spanDiagnostics.ts';
+
+const nonRecordingSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
 
 const carrierGetter = {
   get(carrier: ITelemetryCarrier, key: string) {
@@ -44,10 +54,12 @@ export class ServiceTelemetry extends BeanBase {
   private _enabled = false;
 
   get enabled() {
+    if (getRequestBoundary()) return false;
     return this._enabled;
   }
 
   init() {
+    if (getRequestBoundary()) return;
     if (this._provider || this._enabled) return;
     const config = this.scope.config;
     this._isTrustedIngress = createIngressTrustChecker(config.ingress);
@@ -96,64 +108,64 @@ export class ServiceTelemetry extends BeanBase {
   }
 
   get activeContext() {
+    if (getRequestBoundary()) return ROOT_CONTEXT;
     return this.ctx?.state.telemetry?.context ?? context.active();
   }
 
   extractCarrier(carrier?: ITelemetryCarrier) {
+    if (getRequestBoundary()) return ROOT_CONTEXT;
     if (!carrier) return context.active();
     return propagation.extract(context.active(), carrier, carrierGetter);
   }
 
   isTrustedIngress(peerAddress?: string, internalHeaderValue?: string) {
+    if (getRequestBoundary()) return false;
     this._isTrustedIngress ??= createIngressTrustChecker(this.scope.config.ingress);
     return this._isTrustedIngress(peerAddress, internalHeaderValue);
   }
 
   extractHttpIngressCarrier(trusted: boolean, carrier: ITelemetryCarrier) {
+    if (getRequestBoundary()) return ROOT_CONTEXT;
     return trusted ? this.extractCarrier(carrier) : this.extractCarrier();
   }
 
-  injectCarrier(source = this.activeContext): ITelemetryCarrier {
+  injectCarrier(source?: Context): ITelemetryCarrier {
+    if (getRequestBoundary()) return { version: 1 };
     const carrier: ITelemetryCarrier = { version: 1 };
-    propagation.inject(source, carrier, carrierSetter);
+    propagation.inject(source === undefined ? this.activeContext : source, carrier, carrierSetter);
     return carrier;
   }
 
-  startSpan(name: string, options?: SpanOptions, parent = this.activeContext) {
-    return trace.getTracer('vona-module-a-telemetry').startSpan(name, options, parent);
+  startSpan(name: string, options?: SpanOptions, parent?: Context) {
+    if (getRequestBoundary()) return nonRecordingSpan;
+    return trace
+      .getTracer('vona-module-a-telemetry')
+      .startSpan(name, options, parent === undefined ? this.activeContext : parent);
   }
 
   withSpan<RESULT>(span: Span, fn: () => RESULT): RESULT {
+    if (getRequestBoundary()) return fn();
     const active = trace.setSpan(this.activeContext, span);
     return context.with(active, fn);
   }
 
-  createContext(span: Span, parent = this.activeContext) {
-    return trace.setSpan(parent, span);
+  createContext(span: Span, parent?: Context) {
+    if (getRequestBoundary()) return ROOT_CONTEXT;
+    return trace.setSpan(parent === undefined ? this.activeContext : parent, span);
   }
 
   recordException(span: Span, error: unknown) {
-    if (error instanceof Error) {
-      span.recordException(error);
-      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-      return;
-    }
-    span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+    if (getRequestBoundary()) return;
+    recordSpanException(span, error, captureRequestBoundary());
   }
 
   endHttpSpan(span: Span, statusCode: number, aborted = false) {
-    if (aborted || statusCode >= 500) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: aborted ? 'client aborted' : undefined,
-      });
-    }
-    span.setAttribute('http.response.status_code', statusCode);
-    if (aborted) span.setAttribute('vona.http.aborted', true);
-    span.end();
+    if (getRequestBoundary()) return;
+    endHttpSpan(span, statusCode, aborted);
   }
 
   getLogContext() {
+    if (getRequestBoundary()) return;
     if (!this._enabled) return;
     const spanContext = trace.getSpanContext(this.activeContext);
     if (!spanContext || !trace.isSpanContextValid(spanContext)) return;
@@ -166,6 +178,7 @@ export class ServiceTelemetry extends BeanBase {
   }
 
   createServerSpan(method: string, parent: Context) {
+    if (getRequestBoundary()) return nonRecordingSpan;
     return this.startSpan(`HTTP ${method}`, { kind: SpanKind.SERVER }, parent);
   }
 
@@ -175,6 +188,7 @@ export class ServiceTelemetry extends BeanBase {
     controllerBeanFullName: string,
     action: string,
   ) {
+    if (getRequestBoundary()) return;
     const span = this.ctx.state.telemetry?.serverSpan;
     if (!span) return;
     span.updateName(`HTTP ${method.toUpperCase()} ${routePath}`);