@zapier/zapier-sdk 0.18.4 → 0.19.0

package/dist/plugins/eventEmission/index.js

@@ -1,336 +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 { createTransport } from "./transport";
-import { generateEventId, getCurrentTimestamp, getReleaseId } from "./utils";
-import { extractUserIdsFromJwt } from "../../api/auth";
-import { resolveAuthToken } from "../../auth";
-import { buildApplicationLifecycleEvent, buildErrorEventWithContext, buildMethodCalledEvent, } from "./builders";
-import { getTrackingBaseUrl } from "../../utils/url-utils";
-// Maximum time to wait for telemetry emission before allowing process to exit
-const TELEMETRY_EMIT_TIMEOUT_MS = 300;
-const APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
-const ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
-const METHOD_CALLED_EVENT_SUBJECT = "platform.sdk.MethodCalledEvent";
-// Track transport success/failure so we only log failure once.
-const transportStates = new WeakMap();
-// Silent emission wrapper with smart first-failure logging
-async function silentEmit(transport, subject, event, userContextPromise) {
-    try {
-        // Get or initialize state for this transport
-        let state = transportStates.get(transport);
-        if (!state) {
-            state = { hasWorked: false, hasLoggedFailure: false };
-            transportStates.set(transport, state);
-        }
-        // Resolve user context and merge into event
-        let enrichedEvent = event;
-        if (userContextPromise) {
-            try {
-                const userContext = await userContextPromise;
-                // Use Object.assign to safely merge user context into event
-                enrichedEvent = Object.assign({}, event, userContext);
-            }
-            catch {
-                // If user context promise fails, continue with original event
-            }
-        }
-        // Fire and forget - don't await the transport
-        transport
-            .emit(subject, enrichedEvent)
-            .then(() => {
-            // Mark as working if any emit succeeds
-            state.hasWorked = true;
-        })
-            .catch((error) => {
-            // Only log if we haven't seen it work and haven't logged yet
-            if (!state.hasWorked && !state.hasLoggedFailure) {
-                state.hasLoggedFailure = true;
-                console.warn(`[zapier-sdk] Tracking failed: ${error.message || "Unknown error"}`);
-                console.warn(`[zapier-sdk] Hint: Set trackingBaseUrl parameter or ZAPIER_TRACKING_BASE_URL environment variable if using custom domains`);
-            }
-        });
-    }
-    catch {
-        // Silently ignore all errors
-    }
-}
-// Helper to get transport config from environment or options
-function getTransportConfig(options) {
-    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 with resolved tracking URL
-    const endpoint = process?.env?.ZAPIER_SDK_TELEMETRY_ENDPOINT ||
-        `${getTrackingBaseUrl({
-            trackingBaseUrl: options?.trackingBaseUrl,
-            baseUrl: options?.baseUrl,
-        })}/api/v4/tracking/event/`;
-    return {
-        type: "http",
-        endpoint,
-    };
-}
-export const eventEmissionPlugin = ({ context }) => {
-    const defaultTransport = getTransportConfig({
-        trackingBaseUrl: context.options.trackingBaseUrl,
-        baseUrl: context.options.baseUrl,
-    });
-    // Merge config: env var takes precedence over options, options take precedence over defaults
-    const config = {
-        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),
-    };
-    // Create getUserContext promise for dynamic user context injection
-    const getUserContext = (async () => {
-        try {
-            const token = await resolveAuthToken({
-                token: context.options.token,
-                getToken: context.options.getToken,
-                baseUrl: context.options.baseUrl,
-                authBaseUrl: context.options.authBaseUrl,
-                authClientId: context.options.authClientId,
-                onEvent: context.options.onEvent,
-                fetch: context.options.fetch,
-            });
-            if (token) {
-                return extractUserIdsFromJwt(token);
-            }
-        }
-        catch {
-            // Fall back to null context on any error
-        }
-        return { customuser_id: null, account_id: null };
-    })();
-    const startupTime = Date.now();
-    let shutdownStartTime = null;
-    // If disabled, return noop implementations
-    if (!config.enabled) {
-        return {
-            context: {
-                eventEmission: {
-                    transport: createTransport({ type: "noop" }),
-                    config,
-                    emit: () => { },
-                    createBaseEvent: async () => ({
-                        event_id: generateEventId(),
-                        timestamp_ms: getCurrentTimestamp(),
-                        release_id: getReleaseId(),
-                        customuser_id: null,
-                        account_id: null,
-                        identity_id: null,
-                        visitor_id: null,
-                        correlation_id: null,
-                    }),
-                    emitMethodCalled: () => { },
-                },
-            },
-        };
-    }
-    let transport;
-    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 = async () => {
-        const 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,
-        };
-        // Enrich with user context if available
-        try {
-            const userContext = await getUserContext;
-            return { ...baseEvent, ...userContext };
-        }
-        catch {
-            // Return base event if user context fails
-            return baseEvent;
-        }
-    };
-    // 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, getUserContext);
-        // Register process event handlers (Node.js only)
-        if (typeof process?.on === "function") {
-            // Handle normal process exit
-            process.on("exit", (code) => {
-                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, getUserContext);
-            });
-            // Handle uncaught exceptions
-            process.on("uncaughtException", async (error) => {
-                let 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,
-                });
-                // Enrich with user context if available
-                try {
-                    const userContext = await getUserContext;
-                    errorEvent = { ...errorEvent, ...userContext };
-                }
-                catch {
-                    // Continue with original event if user context fails
-                }
-                // 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) => {
-                            const timer = setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS);
-                            if (typeof timer.unref === "function") {
-                                timer.unref();
-                            }
-                        }),
-                    ]);
-                }
-                catch {
-                    // Silently ignore telemetry failures
-                }
-            });
-            // Handle unhandled promise rejections
-            process.on("unhandledRejection", async (reason, promise) => {
-                const errorMessage = reason instanceof Error
-                    ? reason.message
-                    : typeof reason === "string"
-                        ? reason
-                        : "Unhandled promise rejection";
-                const errorStack = reason instanceof Error ? reason.stack : null;
-                let 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),
-                    },
-                });
-                // Enrich with user context if available
-                try {
-                    const userContext = await getUserContext;
-                    errorEvent = { ...errorEvent, ...userContext };
-                }
-                catch {
-                    // Continue with original event if user context fails
-                }
-                // Wait up to 300ms for telemetry to send
-                try {
-                    await Promise.race([
-                        transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
-                        new Promise((resolve) => {
-                            const timer = setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS);
-                            if (typeof timer.unref === "function") {
-                                timer.unref();
-                            }
-                        }),
-                    ]);
-                }
-                catch {
-                    // Silently ignore telemetry failures
-                }
-            });
-            // Handle termination signals
-            const handleSignal = async (signal) => {
-                shutdownStartTime = Date.now();
-                const uptime = Date.now() - startupTime;
-                let signalEvent = buildApplicationLifecycleEvent({
-                    lifecycle_event_type: "signal_termination",
-                    signal_name: signal,
-                    uptime_ms: uptime,
-                    is_graceful_shutdown: true,
-                });
-                // Enrich with user context if available
-                try {
-                    const userContext = await getUserContext;
-                    signalEvent = { ...signalEvent, ...userContext };
-                }
-                catch {
-                    // Continue with original event if user context fails
-                }
-                // Wait up to 300ms for telemetry to send
-                try {
-                    await Promise.race([
-                        transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
-                        new Promise((resolve) => {
-                            const timer = setTimeout(resolve, TELEMETRY_EMIT_TIMEOUT_MS);
-                            if (typeof timer.unref === "function") {
-                                timer.unref();
-                            }
-                        }),
-                    ]);
-                }
-                catch {
-                    // Silently ignore telemetry failures
-                }
-                // Exit with appropriate code (128 + signal number)
-                const exitCode = signal === "SIGINT" ? 130 : 143;
-                process.exit(exitCode);
-            };
-            // Register signal handlers
-            ["SIGINT", "SIGTERM"].forEach((signal) => {
-                process.on(signal, () => handleSignal(signal));
-            });
-        }
-    }
-    return {
-        context: {
-            eventEmission: {
-                transport,
-                config,
-                emit: (subject, event) => {
-                    silentEmit(transport, subject, event, getUserContext);
-                },
-                createBaseEvent: createBaseEventHelper,
-                emitMethodCalled: (data) => {
-                    const event = buildMethodCalledEvent(data);
-                    silentEmit(transport, METHOD_CALLED_EVENT_SUBJECT, event, getUserContext);
-                },
-            },
-        },
-    };
-};
-export { buildApplicationLifecycleEvent, buildErrorEventWithContext, buildErrorEvent, createBaseEvent, buildMethodCalledEvent, } from "./builders";
-export * from "./utils";

package/dist/plugins/eventEmission/index.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for Event Emission Plugin
- */
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/eventEmission/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/index.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}