fix: SpanMatcherFn doesn't break inference

Author: niieani

src/v3/matchSpan.ts

@@ -28,14 +28,15 @@ export interface Context<
 /**
  * Function type for matching performance entries.
  */
-export type SpanMatcherFn<
+export interface SpanMatcherFn<
   TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
   AllPossibleScopesT,
-> = ((
-  spanAndAnnotation: SpanAndAnnotation<AllPossibleScopesT>,
-  context: Context<TracerScopeKeysT, AllPossibleScopesT>,
-) => boolean) &
-  SpanMatcherTags
+> extends SpanMatcherTags {
+  (
+    spanAndAnnotation: SpanAndAnnotation<AllPossibleScopesT>,
+    context: Context<TracerScopeKeysT, AllPossibleScopesT>,
+  ): boolean
+}
 
 type NameMatcher<TracerScopeT> =
   | string
@@ -132,11 +133,14 @@ export function withAttributes<
  * A list of scope keys to match against the span.
  */
 export function withMatchingScopes<
-  TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
-  AllPossibleScopesT,
+  const TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
+  const AllPossibleScopesT,
 >(
-  keys: NoInfer<readonly TracerScopeKeysT[]> | true = true,
-): SpanMatcherFn<TracerScopeKeysT, AllPossibleScopesT> {
+  keys: readonly NoInfer<TracerScopeKeysT>[] | true = true,
+): SpanMatcherFn<
+  TracerScopeKeysT & KeysOfUnion<AllPossibleScopesT>,
+  AllPossibleScopesT
+> {
   return ({ span }, { input: { scope }, definition: { scopes } }) => {
     if (!span.scope) return false
     const spanScope = span.scope as AllPossibleScopesT & object

src/v3/test/types.test.ts

@@ -11,14 +11,46 @@ interface ExampleUserScope {
   userId: string
 }
 
+interface ExampleTicketEventScope {
+  ticketId: string
+  eventId: string
+}
+
 interface ExampleCustomFieldScope {
   customFieldId: string
 }
 
+interface ExampleScopeWithMultipleKeys {
+  customId: string
+  customOtherId: string
+}
+
+interface TicketFieldScope {
+  ticketId: string
+  ticketFieldType: 'dropdown'
+}
+interface TicketAppScope {
+  ticketId: string
+  appId: string
+}
+
 type ExampleAllPossibleScopes =
   | ExampleTicketScope
   | ExampleUserScope
   | ExampleCustomFieldScope
+  | ExampleScopeWithMultipleKeys
+  | ExampleTicketEventScope
+
+// TODO:
+// // Helper type to ensure we get a tuple instead of an array type
+// type ToTuple<T extends any[]> = [...T];
+
+// // Main type that transforms union of objects to union of tuples of keys
+// type ObjectKeysToTuple<T> = T extends object
+//   ? ToTuple<keyof T extends infer K ? K extends PropertyKey ? [K] : never : never>
+//   : never;
+
+// type X = ObjectKeysToTuple<ExampleAllPossibleScopes> // ["ticketId"] | ["userId"] | ["customFieldId"] | ["customId", "customOtherId"] | ["ticketId", "eventId"]
 
 const mockSpanWithoutScope = {
   name: 'some-span',
@@ -92,21 +124,24 @@ describe.skip('type tests', () => {
     const ticketActivationTracer = traceManager.createTracer({
       name: 'ticket.activation',
       scopes: ['ticketId'],
+      // scope: 'global',
       requiredToEnd: [{ matchScopes: ['ticketId'] }],
     })
 
     const ticketActivationTracer2 = traceManager.createTracer({
       name: 'ticket.activation',
-      scopes: ['ticketId'],
+      scopes: ['customId', 'customOtherId'],
       requiredToEnd: [
-        // match.withAllConditions(
-        //   match.withName((name, scopes) => name === `${scopes.ticketId}.end`),
-        //   // match.withName('end'),
-        //   // match.withMatchingScopes(['ticketId']),
-        // ),
-        // match.withName((name, scopes) => name === `${scopes.ticketId}.end`),
-        // match.withName('customFieldId'),
-        match.withMatchingScopes(['customFieldId']),
+        match.withAllConditions(
+          match.withName((name, scopes) => name === `${scopes.customId}.end`),
+          match.withName('end'),
+          match.withMatchingScopes(['customId']),
+        ),
+        match.withName((name, scopes) => name === `${scopes.customId}.end`),
+        match.withName('customFieldId'),
+        match.withMatchingScopes(['customId']),
+        // @ts-expect-error invalid scope
+        match.withMatchingScopes(['sticketId']),
       ],
     })
 
@@ -232,6 +267,56 @@ describe.skip('type tests', () => {
     })
   })
 
+  it('mixed scopes', () => {
+    const tracer = traceManager.createTracer({
+      name: 'ticket.scope-operation',
+      type: 'operation',
+      scopes: ['ticketId', 'customFieldId'],
+      timeoutDuration: 5_000,
+      requiredToEnd: [{ name: 'end', matchScopes: true }],
+    })
+    const traceId = tracer.start({
+      scope: {
+        customFieldId: '3',
+        ticketId: '4',
+      },
+    })
+  })
+
+  it('redaction example', () => {
+    const tracer = traceManager.createTracer({
+      name: 'ticket.event.redacted',
+      type: 'operation',
+      scopes: ['ticketId', 'eventId'],
+      timeoutDuration: 5_000,
+      requiredToEnd: [{ name: 'OmniLogEvent', matchScopes: true }],
+      debounceOn: [{ name: 'OmniLog', matchScopes: ['ticketId'] }],
+    })
+    const traceId = tracer.start({
+      scope: {
+        ticketId: '4',
+        eventId: '3',
+      },
+    })
+  })
+
+  it('redaction invalid example', () => {
+    const tracer = traceManager.createTracer({
+      name: 'ticket.event.redacted',
+      type: 'operation',
+      // @ts-expect-error enforce a complete set of keys of a given scope
+      scopes: ['eventId'],
+      timeoutDuration: 5_000,
+      requiredToEnd: [{ name: 'OmniLogEvent', matchScopes: true }],
+    })
+    const traceId = tracer.start({
+      scope: {
+        ticketId: '4',
+        eventId: '3',
+      },
+    })
+  })
+
   it('does not allow to include invalid scope key', () => {
     const tracer = traceManager.createTracer({
       name: 'ticket.scope-operation',

src/v3/traceManager.test.ts

@@ -5,6 +5,8 @@ import { ensureTimestamp } from './ensureTimestamp'
 import { createQuietWindowDurationCalculator } from './getDynamicQuietWindowDuration'
 import * as matchSpan from './matchSpan'
 import type { Span } from './spanTypes'
+import { shouldCompleteAndHaveInteractiveTime } from './test/fixtures/shouldCompleteAndHaveInteractiveTime'
+import { shouldNotEndWithInteractiveTimeout } from './test/fixtures/shouldNotEndWithInteractiveTimeout'
 import {
   type TicketIdScope,
   ticketActivationDefinition,
@@ -17,8 +19,6 @@ import {
   Render,
 } from './test/makeTimeline'
 import processSpans from './test/processSpans'
-import { shouldCompleteAndHaveInteractiveTime } from './test/fixtures/shouldCompleteAndHaveInteractiveTime'
-import { shouldNotEndWithInteractiveTimeout } from './test/fixtures/shouldNotEndWithInteractiveTimeout'
 // import { shouldNotEndWithInterruption } from './test/fixtures/shouldNotEndWithInterruption'
 import { TraceManager } from './traceManager'
 import type { ReportFn } from './types'

src/v3/types.ts

@@ -321,6 +321,18 @@ export interface ComputedValueDefinitionInput<
   ) => number | string | boolean
 }
 
+// export type SelectScopeByKey<
+//   SelectScopeKeyT extends keyof ScopesT,
+//   ScopesT,
+// > = Prettify<
+//   ScopesT extends (
+//     SelectScopeKeyT extends SelectScopeKeyT
+//       ? { [AnyKey in SelectScopeKeyT]: ScopeValue }
+//       : never
+//   )
+//     ? ScopesT
+//     : never
+// >
 export type SelectScopeByKey<
   SelectScopeKeyT extends keyof ScopesT,
   ScopesT,