feat(core): share the OTLP resource builder and emit os.name/os.version

Logs, metrics and spans build resource attributes through one function
instead of three copies. Node and browser now contribute the host OS,
matching what react-native already sends.

Author: turnipdabeets

.changeset/otlp-os-resource-attributes.md

@@ -0,0 +1,7 @@
+---
+'posthog-js': minor
+'posthog-node': minor
+'@posthog/core': patch
+---
+
+Add `os.name` and `os.version` resource attributes to the logs and spans sent by `posthog-js` and `posthog-node`.

packages/browser/src/__tests__/logs-defaults.test.ts

@@ -110,4 +110,50 @@ describe('resolveLogsConfig', () => {
 
         expect(resolved.serviceName).toBe('from-named')
     })
+    describe('OS resource attributes', () => {
+        const setUserAgent = (value: string | undefined): void => {
+            Object.defineProperty(window.navigator, 'userAgent', { value, configurable: true })
+        }
+
+        afterEach(() => {
+            // @ts-expect-error restoring the jsdom prototype getter
+            delete window.navigator.userAgent
+        })
+
+        it('attaches the detected OS', () => {
+            setUserAgent(
+                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+            )
+
+            expect(resolveLogsConfig(undefined).resourceAttributes).toEqual({
+                'os.name': 'Mac OS X',
+                'os.version': '10.15.7',
+            })
+        })
+
+        it('lets user resourceAttributes override the detected OS', () => {
+            setUserAgent(
+                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+            )
+
+            expect(
+                resolveLogsConfig({ resourceAttributes: { 'os.name': 'my-os', 'os.version': '1.2.3' } })
+                    .resourceAttributes
+            ).toEqual({ 'os.name': 'my-os', 'os.version': '1.2.3' })
+        })
+
+        it('omits a key the user agent cannot supply rather than emitting it empty', () => {
+            setUserAgent('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0')
+
+            expect(resolveLogsConfig(undefined).resourceAttributes).toEqual({ 'os.name': 'Linux' })
+        })
+
+        it('resolves without OS keys when there is no user agent', () => {
+            setUserAgent(undefined)
+
+            expect(resolveLogsConfig({ resourceAttributes: { 'host.name': 'web-01' } }).resourceAttributes).toEqual({
+                'host.name': 'web-01',
+            })
+        })
+    })
 })

packages/browser/src/logs-defaults.ts

@@ -1,6 +1,7 @@
 import type { LogCaptureOptions } from '@posthog/types'
 import type { ResolvedPostHogLogsConfig } from '@posthog/core'
-import { isUndefined } from '@posthog/core'
+import { detectOS, isUndefined } from '@posthog/core'
+import { navigator } from '@posthog/browser-common/utils/globals'
 
 const DEFAULT_FLUSH_INTERVAL_MS = 3000
 const DEFAULT_MAX_BUFFER_SIZE = 100
@@ -9,6 +10,30 @@ const DEFAULT_MAX_LOGS_PER_INTERVAL = 1000
 const DEFAULT_CONSOLE_MAX_QUEUE_SIZE = 2048
 const DEFAULT_MAX_BATCH_RECORDS_PER_POST = 100
 
+/**
+ * Browser resource attribute defaults. Identifies the visitor's OS so logs can
+ * be filtered by platform (e.g. "only errors on Windows" in the PostHog UI).
+ * User-supplied `resourceAttributes` merges last so these stay overridable.
+ *
+ * `detectOS` returns empty strings for a user agent it can't place, and there is
+ * no `navigator` in an SSR or worker-like context — either way the key is
+ * omitted rather than emitted empty, and resolution never throws.
+ */
+function defaultResourceAttributes(): Record<string, string> {
+    let osName = ''
+    let osVersion = ''
+    try {
+        const userAgent = navigator?.userAgent
+        if (userAgent) {
+            ;[osName, osVersion] = detectOS(userAgent)
+        }
+    } catch {}
+    return {
+        ...(osName ? { 'os.name': osName } : {}),
+        ...(osVersion ? { 'os.version': osVersion } : {}),
+    }
+}
+
 /**
  * Resolves the public `logs` config into the shape core `PostHogLogs` consumes.
  *
@@ -31,7 +56,7 @@ export function resolveLogsConfig(
         ? Math.max(maxBufferSize, DEFAULT_CONSOLE_MAX_QUEUE_SIZE)
         : Math.max(maxBufferSize, maxLogsPerInterval)
     // OTLP keys in `resourceAttributes` take precedence over the named config fields.
-    const resourceAttributes = config?.resourceAttributes
+    const resourceAttributes = { ...defaultResourceAttributes(), ...config?.resourceAttributes }
     return {
         serviceName:
             (resourceAttributes?.['service.name'] as string | undefined) ??

packages/core/src/logs/logs-utils.ts

@@ -12,6 +12,7 @@ import type { LogSdkContext, ResolvedPostHogLogsConfig } from './types'
 import { isNullish, isNumber, isUndefined } from '../utils'
 import { sanitizeString, UNSERIALIZABLE_VALUE } from '../utils/json-utils'
 import { toOtlpKeyValueList } from '../utils/otlp-any-value'
+import { buildOtlpResourceAttributes } from '../utils/otlp-resource'
 
 // ============================================================================
 // Severity mapping
@@ -185,14 +186,7 @@ export function buildResourceAttributes(
   sdkName: string,
   sdkVersion: string
 ): Record<string, LogAttributeValue> {
-  return {
-    ...config.resourceAttributes,
-    'service.name': config.serviceName || 'unknown_service',
-    ...(config.environment && { 'deployment.environment': config.environment }),
-    ...(config.serviceVersion && { 'service.version': config.serviceVersion }),
-    'telemetry.sdk.name': sdkName,
-    'telemetry.sdk.version': sdkVersion,
-  }
+  return buildOtlpResourceAttributes(config, sdkName, sdkVersion)
 }
 
 /**

packages/core/src/metrics/metrics-utils.ts

@@ -1,5 +1,6 @@
 import type { MetricAttributeValue, OtlpMetric, OtlpMetricsPayload } from '@posthog/types'
 import { toOtlpKeyValueList } from '../utils/otlp-any-value'
+import { buildOtlpResourceAttributes } from '../utils/otlp-resource'
 import type { ResolvedPostHogMetricsConfig } from './types'
 
 /**
@@ -59,14 +60,7 @@ export function buildMetricsResourceAttributes(
   scopeName: string,
   scopeVersion: string
 ): Record<string, MetricAttributeValue> {
-  return {
-    ...config.resourceAttributes,
-    'service.name': config.serviceName || 'unknown_service',
-    ...(config.environment && { 'deployment.environment': config.environment }),
-    ...(config.serviceVersion && { 'service.version': config.serviceVersion }),
-    'telemetry.sdk.name': scopeName,
-    'telemetry.sdk.version': scopeVersion,
-  }
+  return buildOtlpResourceAttributes(config, scopeName, scopeVersion)
 }
 
 /**

packages/core/src/traces/otlp.ts

@@ -10,6 +10,7 @@ import type {
 import type { Logger } from '../types'
 import type { ResolvedTracesConfig, SpanRecord } from './types'
 import { toOtlpKeyValueList } from '../utils/otlp-any-value'
+import { buildOtlpResourceAttributes } from '../utils/otlp-resource'
 
 const SPAN_KIND_TO_OTLP: Record<SpanKind, number> = {
   internal: 1,
@@ -108,14 +109,7 @@ export function buildTracesResourceAttributes(
   sdkName: string,
   sdkVersion: string
 ): SpanAttributes {
-  return {
-    ...config.resourceAttributes,
-    'service.name': config.serviceName || 'unknown_service',
-    ...(config.environment && { 'deployment.environment': config.environment }),
-    ...(config.serviceVersion && { 'service.version': config.serviceVersion }),
-    'telemetry.sdk.name': sdkName,
-    'telemetry.sdk.version': sdkVersion,
-  }
+  return buildOtlpResourceAttributes(config, sdkName, sdkVersion)
 }
 
 /**

packages/core/src/utils/otlp-resource.spec.ts

@@ -0,0 +1,83 @@
+import { buildResourceAttributes } from '../logs/logs-utils'
+import type { ResolvedPostHogLogsConfig } from '../logs/types'
+import { buildMetricsResourceAttributes } from '../metrics/metrics-utils'
+import type { ResolvedPostHogMetricsConfig } from '../metrics/types'
+import { buildTracesResourceAttributes } from '../traces/otlp'
+import type { ResolvedTracesConfig } from '../traces/types'
+
+const shared = {
+  serviceName: 'checkout',
+  serviceVersion: '2.1.0',
+  environment: 'production',
+  resourceAttributes: { 'host.name': 'web-01' },
+}
+
+const conflicting = {
+  serviceName: 'checkout',
+  serviceVersion: '2.1.0',
+  environment: 'production',
+  resourceAttributes: {
+    'service.name': 'hijacked',
+    'service.version': '0.0.0',
+    'deployment.environment': 'hijacked-env',
+    'telemetry.sdk.name': 'hijacked-sdk',
+    'telemetry.sdk.version': '0.0.0',
+    'host.name': 'web-01',
+  },
+}
+
+const allThree = (partial: object): Record<string, unknown>[] => [
+  buildResourceAttributes(partial as ResolvedPostHogLogsConfig, 'posthog-node', '1.0.0'),
+  buildMetricsResourceAttributes(partial as ResolvedPostHogMetricsConfig, 'posthog-node', '1.0.0'),
+  buildTracesResourceAttributes(partial as ResolvedTracesConfig, 'posthog-node', '1.0.0'),
+]
+
+describe('shared OTLP resource attributes', () => {
+  it.each([
+    ['a fully populated config', shared],
+    ['a config with conflicting user attributes', conflicting],
+    ['an empty config', {}],
+  ])('produces the same attributes for logs, metrics and traces given %s', (_label, config) => {
+    const [logs, metrics, traces] = allThree(config)
+    expect(metrics).toEqual(logs)
+    expect(traces).toEqual(logs)
+    expect(Object.keys(metrics)).toEqual(Object.keys(logs))
+    expect(Object.keys(traces)).toEqual(Object.keys(logs))
+  })
+
+  it('layers the identity keys over user resource attributes', () => {
+    for (const attributes of allThree(conflicting)) {
+      expect(attributes).toEqual({
+        'service.name': 'checkout',
+        'service.version': '2.1.0',
+        'deployment.environment': 'production',
+        'telemetry.sdk.name': 'posthog-node',
+        'telemetry.sdk.version': '1.0.0',
+        'host.name': 'web-01',
+      })
+    }
+  })
+
+  it('keeps user resource attributes that do not collide', () => {
+    for (const attributes of allThree(shared)) {
+      expect(attributes).toEqual({
+        'host.name': 'web-01',
+        'service.name': 'checkout',
+        'deployment.environment': 'production',
+        'service.version': '2.1.0',
+        'telemetry.sdk.name': 'posthog-node',
+        'telemetry.sdk.version': '1.0.0',
+      })
+    }
+  })
+
+  it('falls back to unknown_service and omits unset optional keys', () => {
+    for (const attributes of allThree({})) {
+      expect(attributes).toEqual({
+        'service.name': 'unknown_service',
+        'telemetry.sdk.name': 'posthog-node',
+        'telemetry.sdk.version': '1.0.0',
+      })
+    }
+  })
+})

packages/core/src/utils/otlp-resource.ts

@@ -0,0 +1,36 @@
+/**
+ * Shape the logs, metrics and traces resolved configs share for resource
+ * attribution. Generic over the attribute value type so each signal keeps its
+ * own value union.
+ */
+export interface OtlpResourceConfig<TAttributeValue> {
+  serviceName?: string
+  serviceVersion?: string
+  environment?: string
+  resourceAttributes?: Record<string, TAttributeValue>
+}
+
+/**
+ * OTLP resource attributes shared by the logs, metrics and traces envelopes.
+ *
+ * User `resourceAttributes` are spread first, then SDK-controlled keys on top so
+ * a stray user key can't clobber the ingestion-attribution ones; the dedicated
+ * `serviceName` / `environment` / `serviceVersion` fields are how you override
+ * those three.
+ *
+ * @internal Shared within this SDK; not part of the stable public API.
+ */
+export function buildOtlpResourceAttributes<TAttributeValue>(
+  config: OtlpResourceConfig<TAttributeValue>,
+  sdkName: string,
+  sdkVersion: string
+): Record<string, TAttributeValue | string> {
+  return {
+    ...config.resourceAttributes,
+    'service.name': config.serviceName || 'unknown_service',
+    ...(config.environment && { 'deployment.environment': config.environment }),
+    ...(config.serviceVersion && { 'service.version': config.serviceVersion }),
+    'telemetry.sdk.name': sdkName,
+    'telemetry.sdk.version': sdkVersion,
+  }
+}

packages/node/src/__tests__/host-os.spec.ts

@@ -0,0 +1,34 @@
+import { platform, release } from 'node:os'
+import { hostOsResourceAttributes } from '../host-os.node'
+
+jest.mock('node:os', () => ({ platform: jest.fn(), release: jest.fn() }))
+
+const mockPlatform = platform as jest.Mock
+const mockRelease = release as jest.Mock
+
+describe('hostOsResourceAttributes', () => {
+  it('reports the host OS', () => {
+    mockPlatform.mockReturnValue('linux')
+    mockRelease.mockReturnValue('6.1.0-27-amd64')
+
+    expect(hostOsResourceAttributes()).toEqual({ 'os.name': 'linux', 'os.version': '6.1.0-27-amd64' })
+  })
+
+  it('omits a key node:os cannot supply rather than emitting it empty', () => {
+    mockPlatform.mockReturnValue('linux')
+    mockRelease.mockReturnValue('')
+
+    expect(hostOsResourceAttributes()).toEqual({ 'os.name': 'linux' })
+  })
+
+  it('returns no attributes when node:os throws', () => {
+    mockPlatform.mockImplementation(() => {
+      throw new Error('unsupported')
+    })
+    mockRelease.mockImplementation(() => {
+      throw new Error('unsupported')
+    })
+
+    expect(hostOsResourceAttributes()).toEqual({})
+  })
+})

packages/node/src/__tests__/traces-defaults.spec.ts

@@ -71,4 +71,25 @@ describe('resolveTracesConfig', () => {
   it('floors an explicit maxQueueSize at the export batch size', () => {
     expect(resolveTracesConfig({ maxExportBatchSize: 512, maxQueueSize: 10 }).maxQueueSize).toBe(512)
   })
+
+  it('attaches the host resource attributes the entrypoint supplies', () => {
+    expect(
+      resolveTracesConfig(undefined, { 'os.name': 'linux', 'os.version': '6.1.0-27-amd64' }).resourceAttributes
+    ).toEqual({ 'os.name': 'linux', 'os.version': '6.1.0-27-amd64' })
+  })
+
+  it('lets user resource attributes override the host ones', () => {
+    expect(
+      resolveTracesConfig(
+        { resourceAttributes: { 'os.name': 'my-os', 'os.version': '1.2.3' } },
+        { 'os.name': 'linux', 'os.version': '6.1.0-27-amd64' }
+      ).resourceAttributes
+    ).toEqual({ 'os.name': 'my-os', 'os.version': '1.2.3' })
+  })
+
+  it('resolves when the entrypoint supplies no host attributes', () => {
+    expect(resolveTracesConfig({ resourceAttributes: { 'host.name': 'worker-01' } }).resourceAttributes).toEqual({
+      'host.name': 'worker-01',
+    })
+  })
 })