✨ [RUM-14514] support session and view attribution by event startTime

[bcaudan]

Motivation

Events must be attributed to the session and view that were active at the event start time, not the current ones.

Changes

• Introduce TimeStampValueHistory and DiskValueHistory for temporal context lookups
• Extract SessionContext and ViewContext into dedicated domain subdirectories
• Enforce TimeStamp typing for startTime in hooks and Assembly
• Fix Assembly combine order so raw event attributes override hook attributes
• Add e2e scenario proving error attribution to correct session/view by startTime

Test instructions

See e2e scenario context.scenario.ts

Checklist

• Tested locally (playground)
• Added unit tests for this change.
• Added e2e/integration tests for this change.
• Updated related documentation.

[cdn34dd]

Overall looks good, just left a couple of suggestions.

[cdn34dd]

Is this change in priority intentional ? If so was is the reason behind it ?

[bcaudan]

Yes, that it is the purpose of 3691760

The same order is used in browser-sdk, the idea is that the hooks can provide some data that can be overwritten by the event, as it should be more specific.
Like the global context should be overwritten by the event specific context.
Here, it was to ensure that we have the event date and not the default date provided by commonContext.

[cdn34dd]

Pretty much all of the logic in both SessionContext and ViewContext is identical and since this pattern is something we could need in the future, I feel we should organize this a bit better. My suggestion would be to move all of the shared logic to an Abstract class, maybe something along these lines:

export abstract class DiskBackedContext {
  private readonly history: DiskValueHistory<string>;

  protected constructor(history: DiskValueHistory<string>, hooks: FormatHooks) {
    this.history = history;

    hooks.registerRum((params) => {
      const id = this.history.find(params.startTime);
      if (id === undefined) return DISCARDED;
      return this.formatRum(id);
    });

    hooks.registerTelemetry((params) => {
      const id = this.history.find(params.startTime);
      if (id === undefined) return SKIPPED;
      return this.formatTelemetry(id);
    });
  }

  protected abstract formatRum(id: string): RecursivePartial<RumEvent>;
  protected abstract formatTelemetry(id: string): RecursivePartial<TelemetryEvent>;

  add(id: string): void {
    this.history.add(id, timeStampNow());
  }

  close(): void {
    this.history.closeActive(timeStampNow());
  }
}

then implement the context classes like so:

export class SessionContext extends DiskBackedContext {
  private constructor(history: DiskValueHistory<string>, hooks: FormatHooks) {
    super(history, hooks);
  }

  static async init(hooks: FormatHooks, expireDelay = SESSION_TIME_OUT_DELAY): Promise<SessionContext> {
    const filePath = path.join(app.getPath('userData'), SESSION_HISTORY_FILE_NAME);
    const history = await DiskValueHistory.init<string>({ filePath, expireDelay });
    return new SessionContext(history, hooks);
  }

  protected formatRum(id: string) {
    return { session: { id } };
  }

  protected formatTelemetry(id: string) {
    return { session: { id } };
  }
}

[bcaudan]

Indeed, we could factorize some things and I like the the fact that we could have a file by concept exposing the different format with less boilerplate.
However, I think we could wait a bit to see how we will handle other contexts like global, user, ...
Unlike session or view, they won't discard events if missing and I'm not sure if we should store them on disk 🤔

I'd be in favor of waiting to make progress on those to have a better understanding of what we should abstract.