Class SpanBuffer

packages/core/src/tracing/spans/spanBuffer.ts:63–195

 * still active and modifyable when child spans are added to the buffer.
 */
export class SpanBuffer {
  /* Bucket spans by their trace id, along with accumulated size and a per-trace flush timeout */
  private _traceBuckets: Map<string, TraceBucket>;

  private _client: Client;
  private _maxSpanLimit: number;
  private _flushInterval: number;
  private _maxTraceWeight: number;

  public constructor(client: Client, options?: SpanBufferOptions) {
    this._traceBuckets = new Map();
    this._client = client;

    const { maxSpanLimit, flushInterval, maxTraceWeightInBytes } = options ?? {};

    this._maxSpanLimit =
      maxSpanLimit && maxSpanLimit > 0 && maxSpanLimit <= MAX_SPANS_PER_ENVELOPE
        ? maxSpanLimit
        : MAX_SPANS_PER_ENVELOPE;
    this._flushInterval = flushInterval && flushInterval > 0 ? flushInterval : 5_000;
    this._maxTraceWeight =
      maxTraceWeightInBytes && maxTraceWeightInBytes > 0 ? maxTraceWeightInBytes : MAX_TRACE_WEIGHT_IN_BYTES;

    this._client.on('flush', () => {
      this.drain();
    });

    this._client.on('close', () => {
      // No need to drain the buffer here as `Client.close()` internally already calls `Client.flush()`
      // which already invokes the `flush` hook and thus drains the buffer.
      this._traceBuckets.forEach(bucket => {
        clearTimeout(bucket.timeout);
      });
      this._traceBuckets.clear();
    });
  }

  /**
   * Add a span to the buffer.
   */
  public add(spanJSON: SerializedStreamedSpanWithSegmentSpan): void {
    const traceId = spanJSON.trace_id;
    let bucket = this._traceBuckets.get(traceId);

    if (!bucket) {
      bucket = {
        spans: new Set(),
        size: 0,
        timeout: safeUnref(
          setTimeout(() => {
            this.flush(traceId);
          }, this._flushInterval),
        ),
      };
      this._traceBuckets.set(traceId, bucket);
    }

    bucket.spans.add(spanJSON);