wip

Author: mormubis

packages/core/src/domain/telemetry/telemetryEvent.types.ts

@@ -209,14 +209,6 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether the allowed tracing urls list is used
        */
       use_allowed_tracing_urls?: boolean
-      /**
-       * Whether the allowed GraphQL urls list is used
-       */
-      use_allowed_graph_ql_urls?: boolean
-      /**
-       * Whether GraphQL payload tracking is used for at least one GraphQL endpoint
-       */
-      use_track_graph_ql_payload?: boolean
       /**
        * A list of selected tracing propagators
        */
@@ -451,22 +443,6 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * The variant of the SDK build (e.g., standard, lite, etc.).
        */
       variant?: string
-      /**
-       * The id of the remote configuration
-       */
-      remote_configuration_id?: string
-      /**
-       * Whether a proxy is used for remote configuration
-       */
-      use_remote_configuration_proxy?: boolean
-      /**
-       * The percentage of sessions with Profiling enabled
-       */
-      profiling_sample_rate?: number
-      /**
-       * Whether trace baggage is propagated to child spans
-       */
-      propagate_trace_baggage?: boolean
       [k: string]: unknown
     }
     [k: string]: unknown

packages/rum-core/src/domain/assembly.ts

@@ -86,6 +86,11 @@ export function startRumAssembly(
       ...VIEW_MODIFIABLE_FIELD_PATHS,
       ...ROOT_MODIFIABLE_FIELD_PATHS,
     },
+    [RumEventType.STREAM]: {
+      ...USER_CUSTOMIZABLE_FIELD_PATHS,
+      ...VIEW_MODIFIABLE_FIELD_PATHS,
+      ...ROOT_MODIFIABLE_FIELD_PATHS,
+    },
   }
   const eventRateLimiters = {
     [RumEventType.ERROR]: createEventRateLimiter(
@@ -109,7 +114,7 @@ export function startRumAssembly(
     LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,
     ({ startTime, duration, rawRumEvent, domainContext }) => {
       const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
-        eventType: rawRumEvent.type,
+        eventType: rawRumEvent.type === 'stream' ? 'view' : rawRumEvent.type,
         startTime,
         duration,
       })!
@@ -126,6 +131,11 @@ export function startRumAssembly(
         if (isEmptyObject(serverRumEvent.context!)) {
           delete serverRumEvent.context
         }
+
+        if (rawRumEvent.type === 'stream') {
+          serverRumEvent.type = 'view'
+        }
+
         lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, serverRumEvent)
       }
     }

packages/rum-core/src/domain/event/eventCollection.ts

@@ -10,6 +10,7 @@ import type {
   RawRumLongTaskEvent,
   RawRumResourceEvent,
   RawRumVitalEvent,
+  RawRumStreamEvent,
 } from '../../rawRumEvent.types'
 import { RumEventType } from '../../rawRumEvent.types'
 
@@ -18,6 +19,7 @@ const allowedEventTypes = [
   RumEventType.ERROR,
   RumEventType.LONG_TASK,
   RumEventType.RESOURCE,
+  RumEventType.STREAM,
   RumEventType.VITAL,
 ] as const
 
@@ -28,6 +30,7 @@ export type AllowedRawRumEvent = (
   | RawRumLongAnimationFrameEvent
   | RawRumActionEvent
   | RawRumVitalEvent
+  | RawRumStreamEvent
 ) & { context?: Context }
 
 export function startEventCollection(lifeCycle: LifeCycle) {

packages/rum-core/src/domain/stream/index.ts

@@ -0,0 +1,32 @@
+import type { RumPlugin, OnRumStartOptions } from '../..'
+import type { AddEvent, API } from './stream'
+import { createStream } from './stream'
+
+export function createStreamPlugin(): { plugin: RumPlugin; createStream: () => ReturnType<typeof createStream> } {
+  let addEvent: OnRumStartOptions['addEvent']
+  const callbacks = new Set<(addEvent: OnRumStartOptions['addEvent']) => void>()
+  const store: AddEvent = (...args) => {
+    callbacks.add(() => {
+      addEvent!(...args)
+    })
+  }
+
+  const api: API = {
+    get addEvent() {
+      return addEvent ?? store
+    },
+  }
+
+  return {
+    plugin: {
+      name: 'stream',
+      onRumStart: (options) => {
+        addEvent = options.addEvent
+
+        callbacks.forEach((callback) => callback(addEvent))
+        callbacks.clear()
+      },
+    },
+    createStream: () => createStream(api),
+  }
+}

packages/rum-core/src/domain/stream/metric.ts

@@ -0,0 +1,19 @@
+// eslint-disable-next-line no-restricted-syntax
+abstract class Metric {
+  constructor(private name: string) {}
+
+  update(value: number, weight?: number): void {
+    // This method is a placeholder for metric updates.
+  }
+}
+
+// eslint-disable-next-line no-restricted-syntax
+export class WeightAverageMetric extends Metric {
+  private average: number = 0
+  private weight: number = 0
+
+  update(value: number, weight: number): void {
+    this.average = (this.average * this.weight + value * weight) / (this.weight + weight)
+    this.weight += weight
+  }
+}

packages/rum-core/src/domain/stream/stream.ts

@@ -0,0 +1,72 @@
+import { clocksNow, generateUUID } from '@datadog/browser-core'
+import type { StartRumResult } from '../..'
+import type { WeightAverageMetric } from './metric'
+import { createTimer } from './timer'
+
+export interface API {
+  addEvent: AddEvent
+}
+
+export type AddEvent = StartRumResult['addEvent']
+
+interface Meta {
+  duration?: number
+  format?: string
+  resolution?: string
+}
+
+interface Metrics {
+  bitrate: WeightAverageMetric
+  fps: WeightAverageMetric
+  timestamp: number
+  watchTime: number
+}
+
+type Transition = 'end' | 'error' | 'pause' | 'play' | 'preload' | 'quit' | 'rebuff' | 'seek' | 'start'
+
+export function createStream(api: API) {
+  const id = generateUUID()
+  const origin = clocksNow()
+  const timer = createTimer()
+
+  return {
+    interaction(id: string): void {},
+    transition(state: Transition, context: any): void {
+      if (state === 'play') {
+        timer.start()
+      }
+
+      if (state === 'pause' || state === 'end') {
+        timer.stop()
+      }
+
+      const now = clocksNow()
+
+      api.addEvent(
+        now.relative,
+        {
+          date: now.timeStamp,
+          type: 'action',
+          action: { id: generateUUID(), type: 'custom', target: { name: state } },
+          stream: { id },
+        },
+        context
+      )
+    },
+    update(key: string, value: any): void {
+      const now = clocksNow()
+
+      api.addEvent(
+        now.relative,
+        {
+          date: now.timeStamp,
+          type: 'stream',
+          stream: {
+            id: generateUUID(),
+          },
+        },
+        {}
+      )
+    },
+  }
+}

packages/rum-core/src/domain/stream/timer.ts

@@ -0,0 +1,22 @@
+import type { RelativeTime } from '@datadog/browser-core'
+import { relativeNow } from '@datadog/browser-core'
+
+export function createTimer() {
+  let start: RelativeTime
+  let count = 0
+
+  return {
+    start(): number {
+      start = relativeNow()
+
+      return count
+    },
+    stop(): number {
+      const duration = relativeNow() - start
+
+      count += duration
+
+      return count
+    },
+  }
+}

packages/rum-core/src/domain/trackEventCounts.ts

@@ -30,7 +30,7 @@ export function trackEventCounts({
   }
 
   const subscription = lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (event): void => {
-    if (event.type === 'view' || event.type === 'vital' || !isChildEvent(event)) {
+    if (event.type === 'view' || event.type === 'vital' || !isChildEvent(event) || ['stream'].includes(event.type)) {
       return
     }
     switch (event.type) {

packages/rum-core/src/domainContext.types.ts

@@ -16,7 +16,9 @@ export type RumEventDomainContext<T extends RumEventType = any> = T extends type
           ? RumLongTaskEventDomainContext
           : T extends typeof RumEventType.VITAL
             ? RumVitalEventDomainContext
-            : never
+            : T extends typeof RumEventType.STREAM
+              ? { streamId: string }
+              : never
 
 export interface RumViewEventDomainContext {
   location: Readonly<Location>
@@ -59,3 +61,5 @@ export interface RumLongTaskEventDomainContext {
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface RumVitalEventDomainContext {}
+
+export interface RumStreamEventDomainContext {}

packages/rum-core/src/index.ts

@@ -71,3 +71,4 @@ export type { Hooks, DefaultRumEventAttributes, DefaultTelemetryEventAttributes
 export { createHooks } from './domain/hooks'
 export { isSampled } from './domain/sampler/sampler'
 export type { TracingOption, PropagatorType } from './domain/tracing/tracer.types'
+export { createStreamPlugin } from './domain/stream'