precompute

Author: chargome

packages/deno/src/integrations/context.ts

@@ -1,4 +1,4 @@
-import type { Event, IntegrationFn } from '@sentry/core';
+import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration, safeSetSpanJSONAttributes } from '@sentry/core';
 
 const INTEGRATION_NAME = 'DenoContext';
@@ -22,42 +22,38 @@ async function getOSRelease(): Promise<string | undefined> {
     : undefined;
 }
 
-async function addDenoRuntimeContext(event: Event): Promise<Event> {
-  event.contexts = {
-    ...{
-      app: {
-        app_start_time: new Date(Date.now() - performance.now()).toISOString(),
-      },
-      device: {
-        arch: Deno.build.arch,
-        // eslint-disable-next-line no-restricted-globals
-        processor_count: navigator.hardwareConcurrency,
-      },
-      os: {
-        name: getOSName(),
-        version: await getOSRelease(),
-      },
-      v8: {
-        name: 'v8',
-        version: Deno.version.v8,
-      },
-      typescript: {
-        name: 'TypeScript',
-        version: Deno.version.typescript,
-      },
-    },
-    ...event.contexts,
+const _denoContextIntegration = (() => {
+  const appStartTime = new Date(Date.now() - performance.now()).toISOString();
+  const osName = getOSName();
+  const arch = Deno.build.arch;
+  // eslint-disable-next-line no-restricted-globals
+  const processorCount = navigator.hardwareConcurrency;
+  const v8Version = Deno.version.v8;
+  const tsVersion = Deno.version.typescript;
+
+  const cachedContext = {
+    app: { app_start_time: appStartTime },
+    device: { arch, processor_count: processorCount },
+    os: { name: osName } as { name: string; version?: string },
+    v8: { name: 'v8', version: v8Version },
+    typescript: { name: 'TypeScript', version: tsVersion },
   };
 
-  return event;
-}
+  const cachedSpanAttributes: Record<string, unknown> = {
+    'app.start_time': appStartTime,
+    // Convention uses 'device.archs' (string[]), but array attributes are not yet serialized.
+    // Once array serialization lands, this will start appearing on spans automatically.
+    'device.archs': [arch],
+    'device.processor_count': processorCount,
+    'os.name': osName,
+    'process.runtime.engine.name': 'v8',
+    'process.runtime.engine.version': v8Version,
+  };
 
-const _denoContextIntegration = (() => {
-  // Eagerly resolve the async OS release so it's available synchronously in processSegmentSpan
-  let cachedOsRelease: string | undefined;
   getOSRelease()
     .then(release => {
-      cachedOsRelease = release;
+      cachedContext.os.version = release;
+      cachedSpanAttributes['os.version'] = release;
     })
     .catch(() => {
       // Ignore - os.version will be undefined
@@ -66,19 +62,14 @@ const _denoContextIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
     processEvent(event) {
-      return addDenoRuntimeContext(event);
+      event.contexts = {
+        ...cachedContext,
+        ...event.contexts,
+      };
+      return event;
     },
     processSegmentSpan(span) {
-      safeSetSpanJSONAttributes(span, {
-        'app.start_time': new Date(Date.now() - performance.now()).toISOString(),
-        'device.archs': [Deno.build.arch],
-        // eslint-disable-next-line no-restricted-globals
-        'device.processor_count': navigator.hardwareConcurrency,
-        'os.name': getOSName(),
-        'os.version': cachedOsRelease,
-        'process.runtime.engine.name': 'v8',
-        'process.runtime.engine.version': Deno.version.v8,
-      });
+      safeSetSpanJSONAttributes(span, cachedSpanAttributes);
     },
   };
 }) satisfies IntegrationFn;