Function apply

packages/core/src/tracing/idleSpan.ts:142–207

(target, thisArg, args: Parameters<Span['end']>)

  // eslint-disable-next-line @typescript-eslint/unbound-method
  span.end = new Proxy(span.end, {
    apply(target, thisArg, args: Parameters<Span['end']>) {
      if (beforeSpanEnd) {
        beforeSpanEnd(span);
      }

      // If the span is non-recording, nothing more to do here...
      // This is the case if tracing is enabled but this specific span was not sampled
      if (spanIsNonRecordingSpan(thisArg)) {
        return;
      }

      // Just ensuring that this keeps working, even if we ever have more arguments here
      const [definedEndTimestamp, ...rest] = args;
      const timestamp = definedEndTimestamp || timestampInSeconds();
      const spanEndTimestamp = spanTimeInputToSeconds(timestamp);

      // Ensure we end with the last span timestamp, if possible
      const spans = getSpanDescendants(span).filter(child => child !== span);

      const spanJson = spanToJSON(span);

      // If we have no spans, we just end, nothing else to do here
      // Likewise, if users explicitly ended the span, we simply end the span without timestamp adjustment
      if (!spans.length || !trimIdleSpanEndTimestamp) {
        onIdleSpanEnded(spanEndTimestamp);
        return Reflect.apply(target, thisArg, [spanEndTimestamp, ...rest]);
      }

      const ignoreSpans = client.getOptions().ignoreSpans;

      const latestSpanEndTimestamp = spans?.reduce((acc: number | undefined, current) => {
        const currentSpanJson = spanToJSON(current);
        if (!currentSpanJson.timestamp) {
          return acc;
        }
        // Ignored spans will get dropped later (in the client) but since we already adjust
        // the idle span end timestamp here, we can already take to-be-ignored spans out of
        // the calculation here.
        if (
          ignoreSpans &&
          shouldIgnoreSpan(
            { description: currentSpanJson.description, op: currentSpanJson.op, attributes: currentSpanJson.data },
            ignoreSpans,
          )
        ) {
          return acc;
        }
        return acc ? Math.max(acc, currentSpanJson.timestamp) : currentSpanJson.timestamp;
      }, undefined);

      // In reality this should always exist here, but type-wise it may be undefined...
      const spanStartTimestamp = spanJson.start_timestamp;

      // The final endTimestamp should:
      // * Never be before the span start timestamp
      // * Be the latestSpanEndTimestamp, if there is one, and it is smaller than the passed span end timestamp
      // * Otherwise be the passed end timestamp
      // Final timestamp can never be after finalTimeout