add transition to draft to active reporting options

Author: xnanodax

src/v3/Trace.ts

@@ -1223,15 +1223,33 @@ export class Trace<
       RelationSchemasT,
       VariantsT
     >,
-  ) {
+    opts?: {
+      noDraftPresentBehavior: 'error' | 'warning' | 'noop'
+    },
+  ): void {
     const { attributes } = this.input
 
     const { relatedTo, errors } = validateAndCoerceRelatedToAgainstSchema(
       inputAndDefinitionModifications.relatedTo,
       this.definition.relationSchema,
     )
-    if (errors.length > 0) {
-      this.traceUtilities.reportWarningFn(
+
+    let reportingFunction
+    const { noDraftPresentBehavior } = opts ?? {}
+
+    switch (noDraftPresentBehavior) {
+      case 'error':
+        reportingFunction = this.traceUtilities.reportErrorFn
+        break
+      case 'noop':
+        reportingFunction = undefined
+        break
+      default:
+        reportingFunction = this.traceUtilities.reportWarningFn
+    }
+
+    if (errors.length > 0 && reportingFunction) {
+      reportingFunction(
         new Error(
           `Invalid relatedTo value: ${JSON.stringify(
             inputAndDefinitionModifications.relatedTo,

src/v3/TraceManagerWithDraft.test.ts

@@ -187,75 +187,144 @@ describe('TraceManager', () => {
     expect(report.duration).toBeNull()
   })
 
-  it('reports error when calling `transitionDraftToActive` when a draft trace has not yet been created', () => {
-    const traceManager = new TraceManager({
-      relationSchemas: { ticket: { ticketId: String } },
-      reportFn,
-      generateId,
-      reportErrorFn,
-      reportWarningFn,
-    })
-
-    const tracer = traceManager.createTracer({
-      name: 'ticket.basic-operation',
-      type: 'operation',
-      relationSchemaName: 'ticket',
-      requiredSpans: [{ name: 'end' }],
-      variants: {
-        cold_boot: { timeout: DEFAULT_COLDBOOT_TIMEOUT_DURATION },
-      },
+  describe('transitionDraftToActive: report errors', () => {
+    it('reports warning when calling `transitionDraftToActive` with no reporting opts when a draft trace has not yet been created', () => {
+      const traceManager = new TraceManager({
+        relationSchemas: { ticket: { ticketId: String } },
+        reportFn,
+        generateId,
+        reportErrorFn,
+        reportWarningFn,
+      })
+
+      const tracer = traceManager.createTracer({
+        name: 'ticket.basic-operation',
+        type: 'operation',
+        relationSchemaName: 'ticket',
+        requiredSpans: [{ name: 'end' }],
+        variants: {
+          cold_boot: { timeout: DEFAULT_COLDBOOT_TIMEOUT_DURATION },
+        },
+      })
+
+      tracer.transitionDraftToActive({ relatedTo: { ticketId: '1' } })
+
+      expect(reportWarningFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining(
+            'No currently active trace when initializing',
+          ),
+        }),
+        expect.objectContaining({
+          definition: expect.any(Object),
+        }),
+      )
     })
 
-    tracer.transitionDraftToActive({ relatedTo: { ticketId: '1' } })
-
-    expect(reportErrorFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: expect.stringContaining(
-          'No currently active trace when initializing',
-        ),
-      }),
-      expect.objectContaining({
-        definition: expect.any(Object),
-      }),
-    )
-  })
-
-  it('reports warning when calling `transitionDraftToActive` again after a trace is active', () => {
-    const traceManager = new TraceManager({
-      relationSchemas: { ticket: { ticketId: String } },
-      reportFn,
-      generateId,
-      reportErrorFn,
-      reportWarningFn,
+    it('reports error when calling `transitionDraftToActive` when reporting with error when a draft trace has not yet been created', () => {
+      const traceManager = new TraceManager({
+        relationSchemas: { ticket: { ticketId: String } },
+        reportFn,
+        generateId,
+        reportErrorFn,
+        reportWarningFn,
+      })
+
+      const tracer = traceManager.createTracer({
+        name: 'ticket.basic-operation',
+        type: 'operation',
+        relationSchemaName: 'ticket',
+        requiredSpans: [{ name: 'end' }],
+        variants: {
+          cold_boot: { timeout: DEFAULT_COLDBOOT_TIMEOUT_DURATION },
+        },
+      })
+
+      tracer.transitionDraftToActive(
+        { relatedTo: { ticketId: '1' } },
+        { noDraftPresentBehavior: 'error' },
+      )
+
+      expect(reportErrorFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining(
+            'No currently active trace when initializing',
+          ),
+        }),
+        expect.objectContaining({
+          definition: expect.any(Object),
+        }),
+      )
+
+      expect(reportWarningFn).not.toHaveBeenCalled()
     })
 
-    const tracer = traceManager.createTracer({
-      name: 'ticket.basic-operation',
-      type: 'operation',
-      relationSchemaName: 'ticket',
-      requiredSpans: [{ name: 'end' }],
-      variants: {
-        cold_boot: { timeout: DEFAULT_COLDBOOT_TIMEOUT_DURATION },
-      },
+    it('does NOT report anything when calling `transitionDraftToActive` when not reporting when a draft trace has not yet been created', () => {
+      const traceManager = new TraceManager({
+        relationSchemas: { ticket: { ticketId: String } },
+        reportFn,
+        generateId,
+        reportErrorFn,
+        reportWarningFn,
+      })
+
+      const tracer = traceManager.createTracer({
+        name: 'ticket.basic-operation',
+        type: 'operation',
+        relationSchemaName: 'ticket',
+        requiredSpans: [{ name: 'end' }],
+        variants: {
+          cold_boot: { timeout: DEFAULT_COLDBOOT_TIMEOUT_DURATION },
+        },
+      })
+
+      tracer.transitionDraftToActive(
+        { relatedTo: { ticketId: '1' } },
+        { noDraftPresentBehavior: 'noop' },
+      )
+
+      expect(reportErrorFn).not.toHaveBeenCalled()
+
+      expect(reportWarningFn).not.toHaveBeenCalled()
     })
 
-    tracer.createDraft({
-      variant: 'cold_boot',
+    it('reports warning when calling `transitionDraftToActive` with no report opts again after a trace is active', () => {
+      const traceManager = new TraceManager({
+        relationSchemas: { ticket: { ticketId: String } },
+        reportFn,
+        generateId,
+        reportErrorFn,
+        reportWarningFn,
+      })
+
+      const tracer = traceManager.createTracer({
+        name: 'ticket.basic-operation',
+        type: 'operation',
+        relationSchemaName: 'ticket',
+        requiredSpans: [{ name: 'end' }],
+        variants: {
+          cold_boot: { timeout: DEFAULT_COLDBOOT_TIMEOUT_DURATION },
+        },
+      })
+
+      tracer.createDraft({
+        variant: 'cold_boot',
+      })
+
+      tracer.transitionDraftToActive({ relatedTo: { ticketId: '1' } })
+      tracer.transitionDraftToActive({ relatedTo: { ticketId: '2' } })
+
+      expect(reportWarningFn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining(
+            'trace that has already been initialized',
+          ),
+        }),
+        expect.objectContaining({
+          definition: expect.any(Object),
+        }),
+      )
     })
-
-    tracer.transitionDraftToActive({ relatedTo: { ticketId: '1' } })
-    tracer.transitionDraftToActive({ relatedTo: { ticketId: '2' } })
-
-    expect(reportWarningFn).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: expect.stringContaining(
-          'trace that has already been initialized',
-        ),
-      }),
-      expect.objectContaining({
-        definition: expect.any(Object),
-      }),
-    )
   })
 
   it('interrupts a draft trace when interrupt() is called with error', () => {

src/v3/Tracer.ts

@@ -208,13 +208,30 @@ export class Tracer<
       RelationSchemasT,
       VariantsT
     >,
+    opts?: {
+      noDraftPresentBehavior: 'error' | 'warning' | 'noop'
+    },
   ): void => {
     const trace:
       | Trace<SelectedRelationNameT, RelationSchemasT, VariantsT>
       | undefined = this.traceUtilities.getCurrentTrace()
 
+    let reportingFunction
+    const { noDraftPresentBehavior } = opts ?? {}
+
+    switch (noDraftPresentBehavior) {
+      case 'error':
+        reportingFunction = this.traceUtilities.reportErrorFn
+        break
+      case 'noop':
+        reportingFunction = undefined
+        break
+      default:
+        reportingFunction = this.traceUtilities.reportWarningFn
+    }
+
     if (!trace) {
-      this.traceUtilities.reportErrorFn(
+      reportingFunction?.(
         new Error(
           `No currently active trace when initializing a trace. Call tracer.start(...) or tracer.createDraft(...) beforehand.`,
         ),
@@ -226,7 +243,7 @@ export class Tracer<
 
     // this is an already initialized active trace, do nothing:
     if (!trace.isDraft) {
-      this.traceUtilities.reportWarningFn(
+      reportingFunction?.(
         new Error(
           `You are trying to initialize a trace that has already been initialized before (${trace.definition.name}).`,
         ),
@@ -238,15 +255,15 @@ export class Tracer<
 
     // verify that trace is the same definition as the Tracer's definition
     if (trace.sourceDefinition !== this.definition) {
-      this.traceUtilities.reportWarningFn(
+      reportingFunction?.(
         new Error(
           `You are trying to initialize a trace that is not the same definition as the Tracer's definition is different.`,
         ),
       )
       return
     }
 
-    trace.transitionDraftToActive(inputAndDefinitionModifications)
+    trace.transitionDraftToActive(inputAndDefinitionModifications, opts)
   }
 
   getCurrentTrace = ():