make peer dependencies optional

Author: chris-olszewski

packages/interceptors-opentelemetry/package.json

@@ -33,6 +33,20 @@
     "@temporalio/worker": "file:../worker",
     "@temporalio/workflow": "file:../workflow"
   },
+  "peerDependenciesMeta": {
+    "@temporalio/activity": {
+      "optional": true
+    },
+    "@temporalio/client": {
+      "optional": true
+    },
+    "@temporalio/worker": {
+      "optional": true
+    },
+    "@temporalio/workflow": {
+      "optional": true
+    }
+  },
   "bugs": {
     "url": "https://github.com/temporalio/sdk-typescript/issues"
   },

packages/interceptors-opentelemetry/src/workflow/context-manager.ts

@@ -1,11 +1,28 @@
 import * as otel from '@opentelemetry/api';
-import { AsyncLocalStorage } from '@temporalio/workflow';
+import type { AsyncLocalStorage as AsyncLocalStorageType } from '@temporalio/workflow';
+
+// @temporalio/workflow is an optional peer dependency.
+// It can be missing as long as the user isn't attempting to construct a workflow interceptor.
+let AsyncLocalStorage: typeof AsyncLocalStorageType | undefined;
+let workflowModuleLoadError: any | undefined;
+try {
+  AsyncLocalStorage = require('@temporalio/workflow').AsyncLocalStorage;
+} catch (err) {
+  // Capture the module not found error to rethrow if an interceptor is constructed
+  workflowModuleLoadError = err;
+}
 
 export class ContextManager implements otel.ContextManager {
-  protected storage = new AsyncLocalStorage<otel.Context>();
+  protected storage = AsyncLocalStorage ? new AsyncLocalStorage<otel.Context>() : undefined;
+
+  public constructor() {
+    if (workflowModuleLoadError) {
+      throw workflowModuleLoadError;
+    }
+  }
 
   active(): otel.Context {
-    return this.storage.getStore() || otel.ROOT_CONTEXT;
+    return this.storage!.getStore() || otel.ROOT_CONTEXT;
   }
 
   bind<T>(context: otel.Context, target: T): T {
@@ -36,7 +53,7 @@ export class ContextManager implements otel.ContextManager {
   }
 
   disable(): this {
-    this.storage.disable();
+    this.storage!.disable();
     return this;
   }
 
@@ -47,6 +64,6 @@ export class ContextManager implements otel.ContextManager {
     ...args: A
   ): ReturnType<F> {
     const cb = thisArg == null ? fn : fn.bind(thisArg);
-    return this.storage.run(context, cb, ...args);
+    return this.storage!.run(context, cb, ...args);
   }
 }

packages/interceptors-opentelemetry/src/workflow/index.ts

@@ -18,11 +18,24 @@ import type {
   WorkflowInternalsInterceptor,
   WorkflowOutboundCallsInterceptor,
 } from '@temporalio/workflow';
-import { ContinueAsNew, workflowInfo } from '@temporalio/workflow';
 import { instrument, extractContextFromHeaders, headersWithContext } from '../instrumentation';
 import { ContextManager } from './context-manager';
 import { SpanName, SPAN_DELIMITER } from './definitions';
 import { SpanExporter } from './span-exporter';
+import type * as WorkflowModule from '@temporalio/workflow';
+
+// @temporalio/workflow is an optional peer dependency.
+// It can be missing as long as the user isn't attempting to construct a workflow interceptor.
+// If we start shipping ES modules alongside CJS, we will have to reconsider
+// this dynamic import as `import` is async for ES modules.
+let workflowModule: typeof WorkflowModule | undefined;
+let workflowModuleLoadError: any | undefined;
+try {
+  workflowModule = require('@temporalio/workflow');
+} catch (err) {
+  // Capture the module not found error to rethrow if an interceptor is constructed
+  workflowModuleLoadError = err;
+}
 
 export * from './definitions';
 
@@ -51,10 +64,18 @@ function getTracer(): otel.Tracer {
 export class OpenTelemetryInboundInterceptor implements WorkflowInboundCallsInterceptor {
   protected readonly tracer = getTracer();
 
+  public constructor() {
+    if (workflowModuleLoadError) {
+      throw workflowModuleLoadError;
+    }
+  }
+
   public async execute(
     input: WorkflowExecuteInput,
     next: Next<WorkflowInboundCallsInterceptor, 'execute'>
   ): Promise<unknown> {
+    // workflowModule will be defined as module load error is checked in the constructor
+    const { workflowInfo, ContinueAsNew } = workflowModule!;
     const context = await extractContextFromHeaders(input.headers);
     return await instrument({
       tracer: this.tracer,
@@ -87,6 +108,12 @@ export class OpenTelemetryInboundInterceptor implements WorkflowInboundCallsInte
 export class OpenTelemetryOutboundInterceptor implements WorkflowOutboundCallsInterceptor {
   protected readonly tracer = getTracer();
 
+  public constructor() {
+    if (workflowModuleLoadError) {
+      throw workflowModuleLoadError;
+    }
+  }
+
   public async scheduleActivity(
     input: ActivityInput,
     next: Next<WorkflowOutboundCallsInterceptor, 'scheduleActivity'>
@@ -142,6 +169,8 @@ export class OpenTelemetryOutboundInterceptor implements WorkflowOutboundCallsIn
     input: ContinueAsNewInput,
     next: Next<WorkflowOutboundCallsInterceptor, 'continueAsNew'>
   ): Promise<never> {
+    // workflowModule will be defined as module load error is checked in the constructor
+    const { ContinueAsNew } = workflowModule!;
     return await instrument({
       tracer: this.tracer,
       spanName: `${SpanName.CONTINUE_AS_NEW}${SPAN_DELIMITER}${input.options.workflowType}`,

packages/interceptors-opentelemetry/src/workflow/runtime.ts

@@ -2,9 +2,18 @@
  * Sets global variables required for importing opentelemetry in isolate
  * @module
  */
-import { inWorkflowContext } from '@temporalio/workflow';
+import type { inWorkflowContext as InWorkflowContext } from '@temporalio/workflow';
 
-if (inWorkflowContext()) {
+// @temporalio/workflow is an optional peer dependency and might not be available.
+// If it is not available, we can assume that we are not in a workflow context.
+let inWorkflowContext: typeof InWorkflowContext | undefined;
+try {
+  inWorkflowContext = require('@temporalio/workflow').inWorkflowContext;
+} catch (_) {
+  inWorkflowContext = undefined;
+}
+
+if (inWorkflowContext && inWorkflowContext()) {
   // Required by opentelemetry (pretend to be a browser)
   Object.assign(globalThis, {
     performance: {

packages/interceptors-opentelemetry/src/workflow/span-exporter.ts

@@ -1,13 +1,33 @@
 import * as tracing from '@opentelemetry/sdk-trace-base';
 import { ExportResult, ExportResultCode } from '@opentelemetry/core';
-import * as wf from '@temporalio/workflow';
 import { OpenTelemetrySinks, SerializableSpan } from './definitions';
 
-const { exporter } = wf.proxySinks<OpenTelemetrySinks>();
+import type * as WorkflowModule from '@temporalio/workflow';
+
+// @temporalio/workflow is an optional peer dependency.
+// It can be missing as long as the user isn't attempting to construct a workflow interceptor.
+// If we start shipping ES modules alongside CJS, we will have to reconsider
+// this dynamic import as `import` is async for ES modules.
+let wf: typeof WorkflowModule | undefined;
+let workflowModuleLoadError: any | undefined;
+try {
+  wf = require('@temporalio/workflow');
+} catch (err) {
+  // Capture the module not found error to rethrow if an interceptor is constructed
+  workflowModuleLoadError = err;
+}
+
+const exporter = wf?.proxySinks<OpenTelemetrySinks>()?.exporter;
 
 export class SpanExporter implements tracing.SpanExporter {
+  public constructor() {
+    if (workflowModuleLoadError) {
+      throw workflowModuleLoadError;
+    }
+  }
+
   public export(spans: tracing.ReadableSpan[], resultCallback: (result: ExportResult) => void): void {
-    exporter.export(spans.map((span) => this.makeSerializable(span)));
+    exporter!.export(spans.map((span) => this.makeSerializable(span)));
     resultCallback({ code: ExportResultCode.SUCCESS });
   }