@getmicdrop/svelte-components 5.20.2 → 5.21.0

package/dist/telemetry.server.spec.js

@@ -1,437 +1,437 @@
-// @ts-nocheck
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Vitest 4.x requires class syntax for constructor mocks
-// Mock all OpenTelemetry modules
-vi.mock('@opentelemetry/instrumentation', () => ({
-  registerInstrumentations: vi.fn(),
-}));
-
-vi.mock('@opentelemetry/sdk-node', () => ({
-  NodeSDK: class MockNodeSDK {
-    constructor() {
-      this.start = vi.fn();
-      this.shutdown = vi.fn(() => Promise.resolve());
-    }
-  },
-}));
-
-vi.mock('@opentelemetry/exporter-trace-otlp-http', () => ({
-  OTLPTraceExporter: class MockOTLPTraceExporter {},
-}));
-
-vi.mock('@opentelemetry/resources', () => ({
-  resourceFromAttributes: vi.fn((attrs) => attrs),
-}));
-
-vi.mock('@opentelemetry/semantic-conventions', () => ({
-  ATTR_SERVICE_NAME: 'service.name',
-  ATTR_SERVICE_VERSION: 'service.version',
-}));
-
-vi.mock('@opentelemetry/instrumentation-http', () => ({
-  HttpInstrumentation: class MockHttpInstrumentation {},
-}));
-
-vi.mock('@opentelemetry/instrumentation-fetch', () => ({
-  FetchInstrumentation: class MockFetchInstrumentation {},
-}));
-
-vi.mock('@opentelemetry/auto-instrumentations-node', () => ({
-  getNodeAutoInstrumentations: vi.fn(() => []),
-}));
-
-const mockSpan = {
-  setAttribute: vi.fn(),
-  setAttributes: vi.fn(),
-  setStatus: vi.fn(),
-  recordException: vi.fn(),
-  end: vi.fn(),
-  spanContext: vi.fn(() => ({
-    traceId: 'test-trace-id',
-    spanId: 'test-span-id',
-  })),
-};
-
-const mockTracer = {
-  startSpan: vi.fn(() => mockSpan),
-};
-
-const mockContext = {
-  active: vi.fn(() => ({})),
-};
-
-const mockPropagation = {
-  extract: vi.fn(() => ({})),
-  inject: vi.fn(),
-};
-
-vi.mock('@opentelemetry/api', () => ({
-  trace: {
-    getTracer: vi.fn(() => mockTracer),
-  },
-  context: mockContext,
-  propagation: mockPropagation,
-}));
-
-describe('telemetry.server.js', () => {
-  let telemetryServer;
-
-  beforeEach(async () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-
-    // Ensure we're in a server environment
-    delete global.window;
-
-    // Stub environment variables
-    vi.stubEnv('VITE_OTEL_TRACES_ENABLED', 'true');
-    vi.stubEnv('VITE_OTEL_SERVICE_NAME', 'test-service');
-    vi.stubEnv('VITE_ENVIRONMENT', 'test');
-
-    telemetryServer = await import('./telemetry.server.js');
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  describe('initServerTelemetry', () => {
-    it('initializes server telemetry when enabled', async () => {
-      const consoleSpy = vi.spyOn(console, 'log');
-
-      // Module auto-initializes, calling initServerTelemetry will re-init
-      telemetryServer.initServerTelemetry();
-
-      expect(consoleSpy).toHaveBeenCalled();
-    });
-
-    it('logs disabled message when tracing is disabled', async () => {
-      vi.resetModules();
-      vi.stubEnv('VITE_OTEL_TRACES_ENABLED', 'false');
-
-      const consoleSpy = vi.spyOn(console, 'log');
-
-      telemetryServer = await import('./telemetry.server.js');
-      telemetryServer.initServerTelemetry();
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[Server Telemetry] Tracing is disabled'
-      );
-    });
-  });
-
-  describe('createSSRSpan', () => {
-    it('creates SSR span with correct name and attributes', () => {
-      const mockRequest = {
-        method: 'GET',
-        url: 'http://localhost:3000/test',
-        headers: {
-          'user-agent': 'test-agent',
-          referer: 'http://localhost:3000/',
-        },
-      };
-
-      const span = telemetryServer.createSSRSpan(
-        'ssr.test',
-        mockRequest,
-        { custom: 'attribute' }
-      );
-
-      expect(mockTracer.startSpan).toHaveBeenCalledWith('ssr.test', {
-        attributes: {
-          'span.kind': 'server',
-          'ssr.type': 'page_load',
-          'portal.type': 'performers',
-          'http.method': 'GET',
-          'http.url': 'http://localhost:3000/test',
-          'http.user_agent': 'test-agent',
-          'http.referer': 'http://localhost:3000/',
-          custom: 'attribute',
-        },
-      });
-
-      expect(span).toBeDefined();
-    });
-
-    it('handles null request gracefully', () => {
-      const span = telemetryServer.createSSRSpan('ssr.null-request', null);
-
-      expect(mockTracer.startSpan).toHaveBeenCalledWith('ssr.null-request', {
-        attributes: {
-          'span.kind': 'server',
-          'ssr.type': 'page_load',
-          'portal.type': 'performers',
-          'http.method': 'GET',
-          'http.url': undefined,
-          'http.user_agent': undefined,
-          'http.referer': undefined,
-        },
-      });
-
-      expect(span).toBeDefined();
-    });
-  });
-
-  describe('trackPerformerSSRDataLoad', () => {
-    it('wraps load function and tracks successful execution', async () => {
-      const mockLoadFn = vi.fn().mockResolvedValue({
-        performer: { id: 1, name: 'Test Performer', email: 'test@test.com' },
-      });
-
-      const mockEvent = {
-        request: {
-          method: 'GET',
-          url: 'http://localhost:3000/performer/1',
-          headers: {},
-        },
-        route: { id: '/performer/[id]' },
-      };
-
-      const wrappedFn = telemetryServer.trackPerformerSSRDataLoad(
-        mockLoadFn,
-        'performer-load'
-      );
-
-      const result = await wrappedFn(mockEvent);
-
-      expect(mockLoadFn).toHaveBeenCalledWith(mockEvent);
-      expect(result.performer.id).toBe(1);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
-      expect(mockSpan.setAttributes).toHaveBeenCalledWith({
-        'performer.id': 1,
-        'performer.name': 'Test Performer',
-        'performer.email': 'test@test.com',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('tracks errors and re-throws them', async () => {
-      const testError = new Error('Load failed');
-      const mockLoadFn = vi.fn().mockRejectedValue(testError);
-
-      const mockEvent = {
-        request: {
-          method: 'GET',
-          url: 'http://localhost:3000/test',
-          headers: {},
-        },
-        route: { id: '/test' },
-      };
-
-      const wrappedFn = telemetryServer.trackPerformerSSRDataLoad(
-        mockLoadFn,
-        'test-load'
-      );
-
-      await expect(wrappedFn(mockEvent)).rejects.toThrow('Load failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: 2,
-        message: 'Load failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('handles results without performer data', async () => {
-      const mockLoadFn = vi.fn().mockResolvedValue({ data: 'test' });
-
-      const mockEvent = {
-        request: {
-          method: 'GET',
-          url: 'http://localhost:3000/test',
-          headers: {},
-        },
-        route: { id: '/test' },
-      };
-
-      const wrappedFn = telemetryServer.trackPerformerSSRDataLoad(
-        mockLoadFn,
-        'test-load'
-      );
-
-      const result = await wrappedFn(mockEvent);
-
-      expect(result.data).toBe('test');
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
-      // setAttributes should not be called for performer data
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-
-  describe('extractTraceContext', () => {
-    it('extracts trace context from request headers', () => {
-      const mockRequest = {
-        headers: new Map([
-          ['x-b3-traceid', 'test-trace'],
-          ['x-b3-spanid', 'test-span'],
-        ]),
-      };
-
-      mockRequest.headers.entries = function () {
-        return this[Symbol.iterator]();
-      };
-
-      telemetryServer.extractTraceContext(mockRequest);
-
-      expect(mockPropagation.extract).toHaveBeenCalled();
-    });
-
-    it('handles null request', () => {
-      const result = telemetryServer.extractTraceContext(null);
-
-      expect(mockPropagation.extract).toHaveBeenCalled();
-    });
-
-    it('handles request without headers', () => {
-      const mockRequest = {};
-
-      const result = telemetryServer.extractTraceContext(mockRequest);
-
-      expect(mockPropagation.extract).toHaveBeenCalled();
-    });
-  });
-
-  describe('injectTraceContext', () => {
-    it('injects trace context into response headers', () => {
-      const mockResponse = {
-        headers: {
-          set: vi.fn(),
-        },
-      };
-
-      mockPropagation.inject.mockImplementation((ctx, headers) => {
-        headers['x-b3-traceid'] = 'injected-trace';
-      });
-
-      telemetryServer.injectTraceContext(mockResponse, mockSpan);
-
-      expect(mockPropagation.inject).toHaveBeenCalled();
-      expect(mockResponse.headers.set).toHaveBeenCalledWith(
-        'X-Trace-Id',
-        'test-trace-id'
-      );
-      expect(mockResponse.headers.set).toHaveBeenCalledWith(
-        'X-Span-Id',
-        'test-span-id'
-      );
-    });
-
-    it('handles null span context', () => {
-      const mockResponse = {
-        headers: {
-          set: vi.fn(),
-        },
-      };
-
-      const nullContextSpan = {
-        spanContext: vi.fn(() => null),
-      };
-
-      // Should not throw
-      expect(() =>
-        telemetryServer.injectTraceContext(mockResponse, nullContextSpan)
-      ).not.toThrow();
-    });
-
-    it('handles response without headers', () => {
-      const mockResponse = {};
-
-      // Should not throw
-      expect(() =>
-        telemetryServer.injectTraceContext(mockResponse, mockSpan)
-      ).not.toThrow();
-    });
-  });
-
-  describe('shutdownServerTelemetry', () => {
-    it('shuts down SDK gracefully', async () => {
-      const consoleSpy = vi.spyOn(console, 'log');
-
-      await telemetryServer.shutdownServerTelemetry();
-
-      // May or may not log depending on SDK state
-      expect(true).toBe(true);
-    });
-  });
-
-  describe('performersPortalTelemetry', () => {
-    it('exports wrapLoad helper', () => {
-      expect(telemetryServer.performersPortalTelemetry.wrapLoad).toBeDefined();
-      expect(
-        typeof telemetryServer.performersPortalTelemetry.wrapLoad
-      ).toBe('function');
-    });
-
-    it('exports wrapAction helper', () => {
-      expect(telemetryServer.performersPortalTelemetry.wrapAction).toBeDefined();
-      expect(
-        typeof telemetryServer.performersPortalTelemetry.wrapAction
-      ).toBe('function');
-    });
-
-    it('wrapLoad returns wrapped function', () => {
-      const mockFn = vi.fn();
-      const wrapped = telemetryServer.performersPortalTelemetry.wrapLoad(
-        mockFn,
-        'test'
-      );
-
-      expect(typeof wrapped).toBe('function');
-    });
-
-    it('wrapAction handles successful action', async () => {
-      const mockActionFn = vi.fn().mockResolvedValue({ success: true });
-
-      const mockEvent = {
-        request: {
-          method: 'POST',
-          url: 'http://localhost:3000/action',
-          headers: {},
-        },
-      };
-
-      const wrappedAction =
-        telemetryServer.performersPortalTelemetry.wrapAction(
-          mockActionFn,
-          'test-action'
-        );
-
-      const result = await wrappedAction(mockEvent);
-
-      expect(mockActionFn).toHaveBeenCalledWith(mockEvent);
-      expect(result.success).toBe(true);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-
-    it('wrapAction handles action errors', async () => {
-      const testError = new Error('Action failed');
-      const mockActionFn = vi.fn().mockRejectedValue(testError);
-
-      const mockEvent = {
-        request: {
-          method: 'POST',
-          url: 'http://localhost:3000/action',
-          headers: {},
-        },
-      };
-
-      const wrappedAction =
-        telemetryServer.performersPortalTelemetry.wrapAction(
-          mockActionFn,
-          'failing-action'
-        );
-
-      await expect(wrappedAction(mockEvent)).rejects.toThrow('Action failed');
-
-      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
-      expect(mockSpan.setStatus).toHaveBeenCalledWith({
-        code: 2,
-        message: 'Action failed',
-      });
-      expect(mockSpan.end).toHaveBeenCalled();
-    });
-  });
-});
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Vitest 4.x requires class syntax for constructor mocks
+// Mock all OpenTelemetry modules
+vi.mock('@opentelemetry/instrumentation', () => ({
+  registerInstrumentations: vi.fn(),
+}));
+
+vi.mock('@opentelemetry/sdk-node', () => ({
+  NodeSDK: class MockNodeSDK {
+    constructor() {
+      this.start = vi.fn();
+      this.shutdown = vi.fn(() => Promise.resolve());
+    }
+  },
+}));
+
+vi.mock('@opentelemetry/exporter-trace-otlp-http', () => ({
+  OTLPTraceExporter: class MockOTLPTraceExporter {},
+}));
+
+vi.mock('@opentelemetry/resources', () => ({
+  resourceFromAttributes: vi.fn((attrs) => attrs),
+}));
+
+vi.mock('@opentelemetry/semantic-conventions', () => ({
+  ATTR_SERVICE_NAME: 'service.name',
+  ATTR_SERVICE_VERSION: 'service.version',
+}));
+
+vi.mock('@opentelemetry/instrumentation-http', () => ({
+  HttpInstrumentation: class MockHttpInstrumentation {},
+}));
+
+vi.mock('@opentelemetry/instrumentation-fetch', () => ({
+  FetchInstrumentation: class MockFetchInstrumentation {},
+}));
+
+vi.mock('@opentelemetry/auto-instrumentations-node', () => ({
+  getNodeAutoInstrumentations: vi.fn(() => []),
+}));
+
+const mockSpan = {
+  setAttribute: vi.fn(),
+  setAttributes: vi.fn(),
+  setStatus: vi.fn(),
+  recordException: vi.fn(),
+  end: vi.fn(),
+  spanContext: vi.fn(() => ({
+    traceId: 'test-trace-id',
+    spanId: 'test-span-id',
+  })),
+};
+
+const mockTracer = {
+  startSpan: vi.fn(() => mockSpan),
+};
+
+const mockContext = {
+  active: vi.fn(() => ({})),
+};
+
+const mockPropagation = {
+  extract: vi.fn(() => ({})),
+  inject: vi.fn(),
+};
+
+vi.mock('@opentelemetry/api', () => ({
+  trace: {
+    getTracer: vi.fn(() => mockTracer),
+  },
+  context: mockContext,
+  propagation: mockPropagation,
+}));
+
+describe('telemetry.server.js', () => {
+  let telemetryServer;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+
+    // Ensure we're in a server environment
+    delete global.window;
+
+    // Stub environment variables
+    vi.stubEnv('VITE_OTEL_TRACES_ENABLED', 'true');
+    vi.stubEnv('VITE_OTEL_SERVICE_NAME', 'test-service');
+    vi.stubEnv('VITE_ENVIRONMENT', 'test');
+
+    telemetryServer = await import('./telemetry.server.js');
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  describe('initServerTelemetry', () => {
+    it('initializes server telemetry when enabled', async () => {
+      const consoleSpy = vi.spyOn(console, 'log');
+
+      // Module auto-initializes, calling initServerTelemetry will re-init
+      telemetryServer.initServerTelemetry();
+
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('logs disabled message when tracing is disabled', async () => {
+      vi.resetModules();
+      vi.stubEnv('VITE_OTEL_TRACES_ENABLED', 'false');
+
+      const consoleSpy = vi.spyOn(console, 'log');
+
+      telemetryServer = await import('./telemetry.server.js');
+      telemetryServer.initServerTelemetry();
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        '[Server Telemetry] Tracing is disabled'
+      );
+    });
+  });
+
+  describe('createSSRSpan', () => {
+    it('creates SSR span with correct name and attributes', () => {
+      const mockRequest = {
+        method: 'GET',
+        url: 'http://localhost:3000/test',
+        headers: {
+          'user-agent': 'test-agent',
+          referer: 'http://localhost:3000/',
+        },
+      };
+
+      const span = telemetryServer.createSSRSpan(
+        'ssr.test',
+        mockRequest,
+        { custom: 'attribute' }
+      );
+
+      expect(mockTracer.startSpan).toHaveBeenCalledWith('ssr.test', {
+        attributes: {
+          'span.kind': 'server',
+          'ssr.type': 'page_load',
+          'portal.type': 'performers',
+          'http.method': 'GET',
+          'http.url': 'http://localhost:3000/test',
+          'http.user_agent': 'test-agent',
+          'http.referer': 'http://localhost:3000/',
+          custom: 'attribute',
+        },
+      });
+
+      expect(span).toBeDefined();
+    });
+
+    it('handles null request gracefully', () => {
+      const span = telemetryServer.createSSRSpan('ssr.null-request', null);
+
+      expect(mockTracer.startSpan).toHaveBeenCalledWith('ssr.null-request', {
+        attributes: {
+          'span.kind': 'server',
+          'ssr.type': 'page_load',
+          'portal.type': 'performers',
+          'http.method': 'GET',
+          'http.url': undefined,
+          'http.user_agent': undefined,
+          'http.referer': undefined,
+        },
+      });
+
+      expect(span).toBeDefined();
+    });
+  });
+
+  describe('trackPerformerSSRDataLoad', () => {
+    it('wraps load function and tracks successful execution', async () => {
+      const mockLoadFn = vi.fn().mockResolvedValue({
+        performer: { id: 1, name: 'Test Performer', email: 'test@test.com' },
+      });
+
+      const mockEvent = {
+        request: {
+          method: 'GET',
+          url: 'http://localhost:3000/performer/1',
+          headers: {},
+        },
+        route: { id: '/performer/[id]' },
+      };
+
+      const wrappedFn = telemetryServer.trackPerformerSSRDataLoad(
+        mockLoadFn,
+        'performer-load'
+      );
+
+      const result = await wrappedFn(mockEvent);
+
+      expect(mockLoadFn).toHaveBeenCalledWith(mockEvent);
+      expect(result.performer.id).toBe(1);
+      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
+      expect(mockSpan.setAttributes).toHaveBeenCalledWith({
+        'performer.id': 1,
+        'performer.name': 'Test Performer',
+        'performer.email': 'test@test.com',
+      });
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
+
+    it('tracks errors and re-throws them', async () => {
+      const testError = new Error('Load failed');
+      const mockLoadFn = vi.fn().mockRejectedValue(testError);
+
+      const mockEvent = {
+        request: {
+          method: 'GET',
+          url: 'http://localhost:3000/test',
+          headers: {},
+        },
+        route: { id: '/test' },
+      };
+
+      const wrappedFn = telemetryServer.trackPerformerSSRDataLoad(
+        mockLoadFn,
+        'test-load'
+      );
+
+      await expect(wrappedFn(mockEvent)).rejects.toThrow('Load failed');
+
+      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
+      expect(mockSpan.setStatus).toHaveBeenCalledWith({
+        code: 2,
+        message: 'Load failed',
+      });
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
+
+    it('handles results without performer data', async () => {
+      const mockLoadFn = vi.fn().mockResolvedValue({ data: 'test' });
+
+      const mockEvent = {
+        request: {
+          method: 'GET',
+          url: 'http://localhost:3000/test',
+          headers: {},
+        },
+        route: { id: '/test' },
+      };
+
+      const wrappedFn = telemetryServer.trackPerformerSSRDataLoad(
+        mockLoadFn,
+        'test-load'
+      );
+
+      const result = await wrappedFn(mockEvent);
+
+      expect(result.data).toBe('test');
+      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
+      // setAttributes should not be called for performer data
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
+  });
+
+  describe('extractTraceContext', () => {
+    it('extracts trace context from request headers', () => {
+      const mockRequest = {
+        headers: new Map([
+          ['x-b3-traceid', 'test-trace'],
+          ['x-b3-spanid', 'test-span'],
+        ]),
+      };
+
+      mockRequest.headers.entries = function () {
+        return this[Symbol.iterator]();
+      };
+
+      telemetryServer.extractTraceContext(mockRequest);
+
+      expect(mockPropagation.extract).toHaveBeenCalled();
+    });
+
+    it('handles null request', () => {
+      const result = telemetryServer.extractTraceContext(null);
+
+      expect(mockPropagation.extract).toHaveBeenCalled();
+    });
+
+    it('handles request without headers', () => {
+      const mockRequest = {};
+
+      const result = telemetryServer.extractTraceContext(mockRequest);
+
+      expect(mockPropagation.extract).toHaveBeenCalled();
+    });
+  });
+
+  describe('injectTraceContext', () => {
+    it('injects trace context into response headers', () => {
+      const mockResponse = {
+        headers: {
+          set: vi.fn(),
+        },
+      };
+
+      mockPropagation.inject.mockImplementation((ctx, headers) => {
+        headers['x-b3-traceid'] = 'injected-trace';
+      });
+
+      telemetryServer.injectTraceContext(mockResponse, mockSpan);
+
+      expect(mockPropagation.inject).toHaveBeenCalled();
+      expect(mockResponse.headers.set).toHaveBeenCalledWith(
+        'X-Trace-Id',
+        'test-trace-id'
+      );
+      expect(mockResponse.headers.set).toHaveBeenCalledWith(
+        'X-Span-Id',
+        'test-span-id'
+      );
+    });
+
+    it('handles null span context', () => {
+      const mockResponse = {
+        headers: {
+          set: vi.fn(),
+        },
+      };
+
+      const nullContextSpan = {
+        spanContext: vi.fn(() => null),
+      };
+
+      // Should not throw
+      expect(() =>
+        telemetryServer.injectTraceContext(mockResponse, nullContextSpan)
+      ).not.toThrow();
+    });
+
+    it('handles response without headers', () => {
+      const mockResponse = {};
+
+      // Should not throw
+      expect(() =>
+        telemetryServer.injectTraceContext(mockResponse, mockSpan)
+      ).not.toThrow();
+    });
+  });
+
+  describe('shutdownServerTelemetry', () => {
+    it('shuts down SDK gracefully', async () => {
+      const consoleSpy = vi.spyOn(console, 'log');
+
+      await telemetryServer.shutdownServerTelemetry();
+
+      // May or may not log depending on SDK state
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('performersPortalTelemetry', () => {
+    it('exports wrapLoad helper', () => {
+      expect(telemetryServer.performersPortalTelemetry.wrapLoad).toBeDefined();
+      expect(
+        typeof telemetryServer.performersPortalTelemetry.wrapLoad
+      ).toBe('function');
+    });
+
+    it('exports wrapAction helper', () => {
+      expect(telemetryServer.performersPortalTelemetry.wrapAction).toBeDefined();
+      expect(
+        typeof telemetryServer.performersPortalTelemetry.wrapAction
+      ).toBe('function');
+    });
+
+    it('wrapLoad returns wrapped function', () => {
+      const mockFn = vi.fn();
+      const wrapped = telemetryServer.performersPortalTelemetry.wrapLoad(
+        mockFn,
+        'test'
+      );
+
+      expect(typeof wrapped).toBe('function');
+    });
+
+    it('wrapAction handles successful action', async () => {
+      const mockActionFn = vi.fn().mockResolvedValue({ success: true });
+
+      const mockEvent = {
+        request: {
+          method: 'POST',
+          url: 'http://localhost:3000/action',
+          headers: {},
+        },
+      };
+
+      const wrappedAction =
+        telemetryServer.performersPortalTelemetry.wrapAction(
+          mockActionFn,
+          'test-action'
+        );
+
+      const result = await wrappedAction(mockEvent);
+
+      expect(mockActionFn).toHaveBeenCalledWith(mockEvent);
+      expect(result.success).toBe(true);
+      expect(mockSpan.setStatus).toHaveBeenCalledWith({ code: 1 });
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
+
+    it('wrapAction handles action errors', async () => {
+      const testError = new Error('Action failed');
+      const mockActionFn = vi.fn().mockRejectedValue(testError);
+
+      const mockEvent = {
+        request: {
+          method: 'POST',
+          url: 'http://localhost:3000/action',
+          headers: {},
+        },
+      };
+
+      const wrappedAction =
+        telemetryServer.performersPortalTelemetry.wrapAction(
+          mockActionFn,
+          'failing-action'
+        );
+
+      await expect(wrappedAction(mockEvent)).rejects.toThrow('Action failed');
+
+      expect(mockSpan.recordException).toHaveBeenCalledWith(testError);
+      expect(mockSpan.setStatus).toHaveBeenCalledWith({
+        code: 2,
+        message: 'Action failed',
+      });
+      expect(mockSpan.end).toHaveBeenCalled();
+    });
+  });
+});