@zapier/zapier-sdk 0.13.6 → 0.13.7

package/src/plugins/eventEmission/builders.ts

@@ -1,115 +0,0 @@
-/**
- * Event builder utilities for creating telemetry events
- *
- * Provides builder functions that auto-populate common fields and ensure
- * schema compliance for all event types.
- */
-
-import type {
-  ErrorOccurredEvent,
-  ApplicationLifecycleEvent,
-  BaseEvent,
-} from "../../types/telemetry-events";
-import type {
-  ApplicationLifecycleEventData,
-  EnhancedErrorEventData,
-  ErrorEventData,
-  EventContext,
-} from "./types";
-import {
-  generateEventId,
-  getCurrentTimestamp,
-  getReleaseId,
-  getOsInfo,
-  getPlatformVersions,
-  getMemoryUsage,
-  getCpuTime,
-  isCi,
-  getCiPlatform,
-} from "./utils";
-import sdkPackageJson from "../../../package.json";
-
-// Create base event with auto-populated common fields
-// Kept for backward compatibility but can be replaced with direct construction
-export function createBaseEvent(context: EventContext = {}): BaseEvent {
-  return {
-    event_id: generateEventId(),
-    timestamp_ms: getCurrentTimestamp(),
-    release_id: getReleaseId(),
-    customuser_id: context.customuser_id,
-    account_id: context.account_id,
-    identity_id: context.identity_id,
-    visitor_id: context.visitor_id,
-    correlation_id: context.correlation_id,
-  };
-}
-
-export function buildErrorEvent(
-  data: ErrorEventData,
-  context: EventContext = {},
-): ErrorOccurredEvent {
-  return {
-    ...createBaseEvent(context),
-    zap_id: context.zap_id,
-    node_id: context.node_id,
-    selected_api: context.selected_api,
-    app_id: context.app_id,
-    app_version_id: context.app_version_id,
-    environment: context.environment,
-    sdk_version: sdkPackageJson.version,
-    ...data,
-  };
-}
-
-export function buildApplicationLifecycleEvent(
-  data: ApplicationLifecycleEventData,
-  context: EventContext = {},
-): ApplicationLifecycleEvent {
-  const osInfo = getOsInfo();
-  const platformVersions = getPlatformVersions();
-
-  return {
-    ...createBaseEvent(context),
-    selected_api: context.selected_api,
-    app_id: context.app_id,
-    app_version_id: context.app_version_id,
-    sdk_version: sdkPackageJson.version,
-    cli_version: null,
-    memory_usage_bytes: data.memory_usage_bytes ?? getMemoryUsage(),
-    peak_memory_usage_bytes: data.peak_memory_usage_bytes ?? getMemoryUsage(),
-    cpu_time_ms: data.cpu_time_ms ?? getCpuTime(),
-    os_platform: osInfo.platform,
-    os_release: osInfo.release,
-    os_architecture: osInfo.architecture,
-    platform_versions: platformVersions,
-    environment: context.environment ?? (process.env.NODE_ENV || null),
-    is_ci_environment: isCi(),
-    ci_platform: getCiPlatform(),
-    session_id: null,
-    metadata: null,
-    process_argv: process.argv || null,
-    ...data,
-  };
-}
-
-export function buildErrorEventWithContext(
-  data: EnhancedErrorEventData,
-  context: EventContext = {},
-): ErrorOccurredEvent {
-  const executionTime = data.execution_start_time
-    ? Date.now() - data.execution_start_time
-    : null;
-
-  return {
-    ...createBaseEvent(context),
-    zap_id: context.zap_id,
-    node_id: context.node_id,
-    selected_api: context.selected_api,
-    app_id: context.app_id,
-    app_version_id: context.app_version_id,
-    environment: context.environment ?? (process.env.NODE_ENV || null),
-    sdk_version: sdkPackageJson.version,
-    execution_time_before_error_ms: executionTime,
-    ...data,
-  };
-}

package/src/plugins/eventEmission/index.test.ts

@@ -1,169 +0,0 @@
-/**
- * Tests for Event Emission Plugin
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { eventEmissionPlugin } from "./index";
-import { createTransport } from "./transport";
-import type { EventEmissionConfig } from "./index";
-
-// Mock transport for testing
-const mockTransport = {
-  emit: vi.fn().mockResolvedValue(undefined),
-  close: vi.fn().mockResolvedValue(undefined),
-};
-
-vi.mock("./transport", () => ({
-  createTransport: vi.fn(() => mockTransport),
-}));
-
-describe("eventEmissionPlugin", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should create plugin with default configuration", () => {
-    const plugin = eventEmissionPlugin({
-      sdk: {},
-      context: {
-        meta: {},
-        options: {},
-      },
-    });
-
-    expect(plugin.context.eventEmission).toBeDefined();
-    expect(plugin.context.eventEmission.emit).toBeDefined();
-    expect(plugin.context.eventEmission.transport).toBeDefined();
-    expect(plugin.context.eventEmission.config).toBeDefined();
-  });
-
-  it("should create noop implementations when disabled", () => {
-    const config: EventEmissionConfig = { enabled: false };
-    const plugin = eventEmissionPlugin({
-      sdk: {},
-      context: {
-        meta: {},
-        options: { eventEmission: config },
-      },
-    });
-
-    // Should not emit any events when disabled
-    plugin.context.eventEmission.emit("platform.sdk.TestEvent", {
-      test_event: "data",
-    });
-
-    expect(mockTransport.emit).not.toHaveBeenCalled();
-  });
-
-  it("should emit events using generic emit method", async () => {
-    const plugin = eventEmissionPlugin({
-      sdk: {},
-      context: {
-        meta: {},
-        options: {
-          eventEmission: {
-            enabled: true,
-            transport: { type: "console" as const },
-          },
-        },
-      },
-    });
-
-    const testEvent = {
-      test_data: "example",
-      value: 123,
-    };
-
-    const testSubject = "test.event.TestEvent";
-
-    plugin.context.eventEmission.emit(testSubject, testEvent);
-
-    // Give async emission time to complete
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(mockTransport.emit).toHaveBeenCalledWith(testSubject, testEvent);
-  });
-
-  it("should handle transport creation failures silently", () => {
-    // Mock createTransport to throw an error
-    vi.mocked(createTransport).mockImplementationOnce(() => {
-      throw new Error("Transport creation failed");
-    });
-
-    expect(() => {
-      eventEmissionPlugin({
-        sdk: {},
-        context: {
-          meta: {},
-          options: {
-            eventEmission: {
-              enabled: true,
-              transport: { type: "http" as const, endpoint: "invalid-url" },
-            },
-          },
-        },
-      });
-    }).not.toThrow();
-  });
-
-  it("should handle event emission failures silently", async () => {
-    // Mock transport to throw error
-    const failingTransport = {
-      emit: vi.fn().mockRejectedValue(new Error("Network error")),
-      close: vi.fn().mockResolvedValue(undefined),
-    };
-
-    vi.mocked(createTransport).mockReturnValueOnce(failingTransport);
-
-    const plugin = eventEmissionPlugin({
-      sdk: {},
-      context: {
-        meta: {},
-        options: {
-          eventEmission: {
-            enabled: true,
-            transport: {
-              type: "http" as const,
-              endpoint: "https://example.com",
-            },
-          },
-        },
-      },
-    });
-
-    // Should not throw even if transport fails
-    expect(() => {
-      plugin.context.eventEmission.emit("test.event.TestEvent", {
-        test_event: "data",
-      });
-    }).not.toThrow();
-
-    // Give async emission time to complete
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    expect(failingTransport.emit).toHaveBeenCalled();
-  });
-
-  it("should merge options with defaults", () => {
-    const plugin = eventEmissionPlugin({
-      sdk: {},
-      context: {
-        meta: {},
-        options: {
-          eventEmission: {
-            transport: {
-              type: "http" as const,
-              endpoint: "https://example.com",
-            },
-          },
-        },
-      },
-    });
-
-    expect(plugin.context.eventEmission.config.enabled).toBe(true);
-    expect(plugin.context.eventEmission.config.transport).toEqual({
-      type: "http",
-      endpoint: "https://example.com",
-    });
-  });
-});

package/src/plugins/eventEmission/index.ts

@@ -1,294 +0,0 @@
-/**
- * Event Emission Plugin for Zapier SDK
- *
- * Provides silent telemetry event emission capability to the SDK.
- * All events are emitted asynchronously and failures are silently handled.
- */
-
-import type { Plugin } from "../../types/plugin";
-import type { BaseEvent } from "../../types/telemetry-events";
-import type { EventTransport, TransportConfig } from "./transport";
-import { createTransport } from "./transport";
-import { generateEventId, getCurrentTimestamp, getReleaseId } from "./utils";
-import {
-  buildApplicationLifecycleEvent,
-  buildErrorEventWithContext,
-} from "./builders";
-import { TRACKING_API_ENDPOINT } from "../../constants";
-
-// Plugin configuration
-export interface EventEmissionConfig {
-  enabled?: boolean;
-  transport?: TransportConfig;
-}
-
-// Context provided by this plugin
-export interface EventEmissionContext {
-  eventEmission: {
-    transport: EventTransport;
-    config: EventEmissionConfig;
-    // Generic event emission method
-    emit<T extends any>(subject: string, event: T): void;
-    // Builder for base event properties
-    createBaseEvent(): BaseEvent;
-  };
-}
-
-export interface EventEmissionProvides {
-  context: EventEmissionContext;
-}
-
-const APPLICATION_LIFECYCLE_EVENT_SUBJECT =
-  "platform.sdk.ApplicationLifecycleEvent";
-const ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
-
-// Silent emission wrapper - ensures events never disrupt SDK operation
-async function silentEmit<T extends any>(
-  transport: EventTransport,
-  subject: string,
-  event: T,
-): Promise<void> {
-  try {
-    // Fire and forget - don't await the transport
-    transport.emit(subject, event).catch(() => {
-      // Silently ignore transport failures
-    });
-  } catch {
-    // Silently ignore all errors
-  }
-}
-
-// Helper to get transport config from environment or defaults
-function getTransportConfig(): TransportConfig {
-  const envTransport = process?.env?.ZAPIER_SDK_TELEMETRY_TRANSPORT;
-
-  if (envTransport === "noop" || envTransport === "disabled") {
-    return { type: "noop" };
-  }
-
-  if (envTransport === "console") {
-    return { type: "console" };
-  }
-
-  // Default to HTTP transport
-  const endpoint =
-    process?.env?.ZAPIER_SDK_TELEMETRY_ENDPOINT || TRACKING_API_ENDPOINT;
-
-  return {
-    type: "http",
-    endpoint,
-  };
-}
-
-export const eventEmissionPlugin: Plugin<
-  {},
-  { options: { eventEmission?: EventEmissionConfig } },
-  EventEmissionProvides
-> = ({ context }) => {
-  const defaultTransport = getTransportConfig();
-
-  // Merge config: env var takes precedence over options, options take precedence over defaults
-  const config: EventEmissionConfig = {
-    enabled: context.options.eventEmission?.enabled ?? true,
-    transport:
-      // If env var is set, use it (defaultTransport will be from env)
-      process?.env?.ZAPIER_SDK_TELEMETRY_TRANSPORT
-        ? defaultTransport
-        : // Otherwise, use option transport or default
-          (context.options.eventEmission?.transport ?? defaultTransport),
-  };
-
-  const startupTime = Date.now();
-  let shutdownStartTime: number | null = null;
-
-  // If disabled, return noop implementations
-  if (!config.enabled) {
-    return {
-      context: {
-        eventEmission: {
-          transport: createTransport({ type: "noop" }),
-          config,
-          emit: () => {},
-          createBaseEvent: (): BaseEvent => ({
-            event_id: generateEventId(),
-            timestamp_ms: getCurrentTimestamp(),
-            release_id: getReleaseId(),
-            customuser_id: null,
-            account_id: null,
-            identity_id: null,
-            visitor_id: null,
-            correlation_id: null,
-          }),
-        },
-      },
-    };
-  }
-
-  let transport: EventTransport;
-  try {
-    transport = createTransport(config.transport || { type: "noop" });
-  } catch {
-    // If transport creation fails, fallback to noop to maintain silent operation
-    transport = createTransport({ type: "noop" });
-  }
-
-  // Helper to create base event
-  const createBaseEventHelper = (): BaseEvent => ({
-    event_id: generateEventId(),
-    timestamp_ms: getCurrentTimestamp(),
-    release_id: getReleaseId(),
-    customuser_id: null,
-    account_id: null,
-    identity_id: null,
-    visitor_id: null,
-    correlation_id: null,
-  });
-
-  // Register lifecycle event handlers if enabled
-  if (config.enabled) {
-    // Emit startup event
-    const startupEvent = buildApplicationLifecycleEvent({
-      lifecycle_event_type: "startup",
-    });
-    silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
-
-    // Register process event handlers (Node.js only)
-    if (typeof process?.on === "function") {
-      // Handle normal process exit
-      process.on("exit", (code: number) => {
-        const uptime = Date.now() - startupTime;
-        const shutdownDuration = shutdownStartTime
-          ? Date.now() - shutdownStartTime
-          : null;
-
-        const exitEvent = buildApplicationLifecycleEvent({
-          lifecycle_event_type: "exit",
-          exit_code: code,
-          uptime_ms: uptime,
-          is_graceful_shutdown: code === 0,
-          shutdown_duration_ms: shutdownDuration,
-        });
-        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
-      });
-
-      // Handle uncaught exceptions
-      process.on("uncaughtException", async (error: Error) => {
-        const errorEvent = buildErrorEventWithContext({
-          error_message: error.message || "Unknown error",
-          error_type: "UncaughtException",
-          error_stack_trace: error.stack || null,
-          error_severity: "critical",
-          is_user_facing: false,
-          is_recoverable: false,
-          execution_start_time: startupTime,
-        });
-
-        // Wait up to 300ms for telemetry to send before allowing process to exit
-        try {
-          await Promise.race([
-            transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-            new Promise((resolve) => setTimeout(resolve, 300)),
-          ]);
-        } catch {
-          // Silently ignore telemetry failures
-        }
-        // Let Node.js exit naturally after all handlers complete
-      });
-
-      // Handle unhandled promise rejections
-      process.on(
-        "unhandledRejection",
-        async (reason: any, promise: Promise<any>) => {
-          const errorMessage =
-            reason instanceof Error
-              ? reason.message
-              : typeof reason === "string"
-                ? reason
-                : "Unhandled promise rejection";
-
-          const errorStack = reason instanceof Error ? reason.stack : null;
-
-          const errorEvent = buildErrorEventWithContext({
-            error_message: errorMessage,
-            error_type: "UnhandledRejection",
-            error_stack_trace: errorStack,
-            error_severity: "critical",
-            is_user_facing: false,
-            is_recoverable: false,
-            execution_start_time: startupTime,
-            error_metadata: {
-              promise: String(promise),
-            },
-          });
-
-          // Wait up to 300ms for telemetry to send
-          try {
-            await Promise.race([
-              transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-              new Promise((resolve) => setTimeout(resolve, 300)),
-            ]);
-          } catch {
-            // Silently ignore telemetry failures
-          }
-        },
-      );
-
-      // Handle termination signals
-      const handleSignal = async (signal: string) => {
-        shutdownStartTime = Date.now();
-        const uptime = Date.now() - startupTime;
-
-        const signalEvent = buildApplicationLifecycleEvent({
-          lifecycle_event_type: "signal_termination",
-          signal_name: signal,
-          uptime_ms: uptime,
-          is_graceful_shutdown: true,
-        });
-
-        // Wait up to 300ms for telemetry to send
-        try {
-          await Promise.race([
-            transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-            new Promise((resolve) => setTimeout(resolve, 300)),
-          ]);
-        } catch {
-          // Silently ignore telemetry failures
-        }
-        // Let other signal handlers run and decide when to exit
-      };
-
-      // Register signal handlers
-      ["SIGINT", "SIGTERM"].forEach((signal) => {
-        process.on(signal as any, () => handleSignal(signal));
-      });
-    }
-  }
-
-  return {
-    context: {
-      eventEmission: {
-        transport,
-        config,
-        emit: <T extends any>(subject: string, event: T) => {
-          silentEmit(transport, subject, event);
-        },
-        createBaseEvent: createBaseEventHelper,
-      },
-    },
-  };
-};
-
-// Export types and utilities for other plugins
-export type {
-  EventContext,
-  ApplicationLifecycleEventData,
-  EnhancedErrorEventData,
-} from "./types";
-export {
-  buildApplicationLifecycleEvent,
-  buildErrorEventWithContext,
-  buildErrorEvent,
-  createBaseEvent,
-} from "./builders";
-export type { BaseEvent } from "../../types/telemetry-events";
-export * from "./utils";