@engjts/nexus 0.1.0

package/dist/advanced/sentry/index.js

@@ -0,0 +1,1002 @@
+"use strict";
+/**
+ * Sentry Integration for Nexus Framework
+ *
+ * Built-in error tracking, performance monitoring, and session replay
+ * with seamless integration to Sentry.io
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SentryClient = void 0;
+exports.createSentryMiddleware = createSentryMiddleware;
+exports.createSentryErrorHandler = createSentryErrorHandler;
+exports.withSpan = withSpan;
+exports.initSentry = initSentry;
+exports.getSentry = getSentry;
+exports.captureException = captureException;
+exports.captureMessage = captureMessage;
+exports.addBreadcrumb = addBreadcrumb;
+exports.setUser = setUser;
+exports.setTag = setTag;
+exports.setExtra = setExtra;
+exports.sentry = sentry;
+const crypto_1 = require("crypto");
+// ============================================
+// APM Manager (Integrated into Sentry)
+// ============================================
+/**
+ * Built-in APM (Application Performance Monitoring)
+ * Automatically enabled when Sentry is initialized
+ */
+class APMIntegration {
+    options;
+    slowQueries = [];
+    memorySnapshots = [];
+    memoryCheckInterval;
+    sentryClient;
+    constructor(options = {}, sentryClient) {
+        this.sentryClient = sentryClient;
+        this.options = {
+            enabled: options.enabled ?? true,
+            slowQueryThreshold: options.slowQueryThreshold ?? 1000,
+            maxSlowQueries: options.maxSlowQueries ?? 100,
+            memoryLeakDetection: {
+                enabled: options.memoryLeakDetection?.enabled ?? true,
+                interval: options.memoryLeakDetection?.interval ?? 60000,
+                growthThreshold: options.memoryLeakDetection?.growthThreshold ?? 0.5,
+                maxSnapshots: options.memoryLeakDetection?.maxSnapshots ?? 60
+            },
+            onMemoryLeak: options.onMemoryLeak,
+            onSlowQuery: options.onSlowQuery
+        };
+        if (this.options.enabled && this.options.memoryLeakDetection.enabled) {
+            this.startMemoryMonitoring();
+        }
+    }
+    /**
+     * Record a database/external query
+     * Automatically reports slow queries to Sentry as breadcrumbs
+     */
+    recordQuery(query, durationMs, metadata) {
+        if (!this.options.enabled)
+            return;
+        const threshold = this.options.slowQueryThreshold;
+        if (durationMs >= threshold) {
+            const record = {
+                query: query.slice(0, 500), // Truncate long queries
+                duration: durationMs,
+                timestamp: Date.now()
+            };
+            this.slowQueries.push(record);
+            // Keep limited slow queries
+            if (this.slowQueries.length > this.options.maxSlowQueries) {
+                this.slowQueries.shift();
+            }
+            // Report to Sentry as breadcrumb
+            if (this.sentryClient) {
+                this.sentryClient.addBreadcrumb({
+                    type: 'query',
+                    category: 'db.query',
+                    message: `Slow query: ${query.slice(0, 100)}...`,
+                    data: {
+                        duration_ms: durationMs,
+                        threshold_ms: threshold,
+                        ...metadata
+                    },
+                    level: durationMs > threshold * 2 ? 'warning' : 'info'
+                });
+            }
+            // Callback
+            this.options.onSlowQuery?.(record);
+        }
+    }
+    /**
+     * Get all recorded slow queries
+     */
+    getSlowQueries() {
+        return [...this.slowQueries];
+    }
+    /**
+     * Clear slow query history
+     */
+    clearSlowQueries() {
+        this.slowQueries = [];
+    }
+    startMemoryMonitoring() {
+        const { interval, maxSnapshots } = this.options.memoryLeakDetection;
+        this.memoryCheckInterval = setInterval(() => {
+            const usage = process.memoryUsage();
+            this.memorySnapshots.push({
+                timestamp: Date.now(),
+                heapUsed: usage.heapUsed,
+                heapTotal: usage.heapTotal
+            });
+            // Keep limited snapshots
+            if (this.memorySnapshots.length > maxSnapshots) {
+                this.memorySnapshots.shift();
+            }
+            // Check for potential memory leak
+            this.checkMemoryLeak();
+        }, interval);
+    }
+    checkMemoryLeak() {
+        if (this.memorySnapshots.length < 10)
+            return;
+        const { growthThreshold } = this.options.memoryLeakDetection;
+        const recent = this.memorySnapshots.slice(-10);
+        const oldest = recent[0].heapUsed;
+        const newest = recent[recent.length - 1].heapUsed;
+        const growth = (newest - oldest) / oldest;
+        // Alert if memory grew more than threshold in the monitoring window
+        if (growth > growthThreshold) {
+            const stats = {
+                growth,
+                growthPercent: `${(growth * 100).toFixed(1)}%`,
+                fromMB: `${(oldest / 1024 / 1024).toFixed(1)}MB`,
+                toMB: `${(newest / 1024 / 1024).toFixed(1)}MB`,
+                snapshots: recent
+            };
+            // Report to Sentry
+            if (this.sentryClient) {
+                this.sentryClient.captureMessage(`Potential memory leak detected: ${stats.growthPercent} growth`, {
+                    level: 'warning',
+                    tags: { type: 'memory_leak' },
+                    extra: stats
+                });
+                this.sentryClient.addBreadcrumb({
+                    type: 'debug',
+                    category: 'memory',
+                    message: `Memory grew ${stats.growthPercent}`,
+                    data: {
+                        from: stats.fromMB,
+                        to: stats.toMB
+                    },
+                    level: 'warning'
+                });
+            }
+            // Callback
+            this.options.onMemoryLeak?.(stats);
+        }
+    }
+    /**
+     * Get current memory statistics
+     */
+    getMemoryStats() {
+        const current = process.memoryUsage();
+        return {
+            current: {
+                heapUsed: current.heapUsed,
+                heapTotal: current.heapTotal,
+                external: current.external,
+                rss: current.rss
+            },
+            history: [...this.memorySnapshots]
+        };
+    }
+    /**
+     * Stop APM monitoring
+     */
+    stop() {
+        if (this.memoryCheckInterval) {
+            clearInterval(this.memoryCheckInterval);
+            this.memoryCheckInterval = undefined;
+        }
+    }
+}
+// ============================================
+// Sentry Client
+// ============================================
+/**
+ * Nexus Sentry Client
+ * Lightweight, built-in Sentry integration with APM
+ */
+class SentryClient {
+    options;
+    dsn;
+    breadcrumbs = [];
+    user;
+    globalTags = {};
+    globalExtra = {};
+    activeTransactions = new Map();
+    isEnabled = true;
+    apm;
+    constructor(options) {
+        // Parse and validate DSN
+        this.dsn = this.parseDSN(options.dsn);
+        this.options = {
+            dsn: options.dsn,
+            environment: options.environment ?? process.env.NODE_ENV ?? 'production',
+            release: options.release ?? process.env.npm_package_version ?? 'unknown',
+            serverName: options.serverName ?? this.getServerName(),
+            sampleRate: options.sampleRate ?? 1.0,
+            tracesSampleRate: options.tracesSampleRate ?? 0.1,
+            enableTracing: options.enableTracing ?? true,
+            maxBreadcrumbs: options.maxBreadcrumbs ?? 100,
+            debug: options.debug ?? false,
+            attachStacktrace: options.attachStacktrace ?? false,
+            sendDefaultPii: options.sendDefaultPii ?? false,
+            beforeSend: options.beforeSend ?? ((event) => event),
+            beforeSendTransaction: options.beforeSendTransaction ?? ((tx) => tx),
+            tags: options.tags ?? {},
+            extra: options.extra ?? {},
+            ignorePaths: options.ignorePaths ?? [],
+            ignoreErrors: options.ignoreErrors ?? [],
+            timeout: options.timeout ?? 5000,
+            integrations: {
+                http: options.integrations?.http ?? true,
+                console: options.integrations?.console ?? false,
+                unhandledRejection: options.integrations?.unhandledRejection ?? true,
+                uncaughtException: options.integrations?.uncaughtException ?? true
+            },
+            apm: options.apm ?? {}
+        };
+        this.globalTags = { ...this.options.tags };
+        this.globalExtra = { ...this.options.extra };
+        // Initialize APM integration
+        this.apm = new APMIntegration(this.options.apm, this);
+        // Setup global handlers
+        this.setupIntegrations();
+        this.log('Sentry initialized', { environment: this.options.environment });
+    }
+    // ============================================
+    // DSN Parsing
+    // ============================================
+    parseDSN(dsn) {
+        try {
+            const url = new URL(dsn);
+            const pathParts = url.pathname.split('/').filter(Boolean);
+            return {
+                protocol: url.protocol.replace(':', ''),
+                publicKey: url.username,
+                host: url.host,
+                projectId: pathParts[pathParts.length - 1]
+            };
+        }
+        catch {
+            throw new Error(`Invalid Sentry DSN: ${dsn}`);
+        }
+    }
+    getEnvelopeEndpoint() {
+        return `${this.dsn.protocol}://${this.dsn.host}/api/${this.dsn.projectId}/envelope/`;
+    }
+    getServerName() {
+        try {
+            return require('os').hostname();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    // ============================================
+    // Integrations
+    // ============================================
+    setupIntegrations() {
+        if (this.options.integrations.unhandledRejection) {
+            process.on('unhandledRejection', (reason) => {
+                this.captureException(reason instanceof Error ? reason : new Error(String(reason)), {
+                    tags: { mechanism: 'unhandledRejection' }
+                });
+            });
+        }
+        if (this.options.integrations.uncaughtException) {
+            process.on('uncaughtException', (error) => {
+                this.captureException(error, {
+                    tags: { mechanism: 'uncaughtException' },
+                    level: 'fatal'
+                });
+                // Allow time for the event to be sent
+                setTimeout(() => process.exit(1), 2000);
+            });
+        }
+    }
+    // ============================================
+    // Core Methods
+    // ============================================
+    /**
+     * Capture an exception and send to Sentry
+     */
+    captureException(error, options = {}) {
+        if (!this.isEnabled || !this.shouldSample(this.options.sampleRate)) {
+            return '';
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        // Check ignore patterns
+        if (this.shouldIgnoreError(err)) {
+            return '';
+        }
+        const eventId = this.generateEventId();
+        const event = this.buildErrorEvent(err, eventId, options);
+        // Apply beforeSend hook
+        const processedEvent = this.options.beforeSend(event, { originalException: err });
+        if (!processedEvent) {
+            this.log('Event dropped by beforeSend');
+            return '';
+        }
+        this.sendEvent(processedEvent);
+        return eventId;
+    }
+    /**
+     * Capture a message
+     */
+    captureMessage(message, options = {}) {
+        if (!this.isEnabled || !this.shouldSample(this.options.sampleRate)) {
+            return '';
+        }
+        const eventId = this.generateEventId();
+        const event = {
+            event_id: eventId,
+            timestamp: Date.now() / 1000,
+            platform: 'node',
+            level: options.level ?? 'info',
+            message,
+            environment: this.options.environment,
+            release: this.options.release,
+            server_name: this.options.serverName,
+            user: options.user ?? this.user,
+            tags: { ...this.globalTags, ...options.tags },
+            extra: { ...this.globalExtra, ...options.extra },
+            breadcrumbs: [...this.breadcrumbs],
+            fingerprint: options.fingerprint
+        };
+        const processedEvent = this.options.beforeSend(event);
+        if (!processedEvent) {
+            return '';
+        }
+        this.sendEvent(processedEvent);
+        return eventId;
+    }
+    /**
+     * Add a breadcrumb
+     */
+    addBreadcrumb(breadcrumb) {
+        const crumb = {
+            timestamp: Date.now() / 1000,
+            ...breadcrumb
+        };
+        this.breadcrumbs.push(crumb);
+        // Limit breadcrumbs
+        if (this.breadcrumbs.length > this.options.maxBreadcrumbs) {
+            this.breadcrumbs.shift();
+        }
+    }
+    /**
+     * Set user context
+     */
+    setUser(user) {
+        this.user = user ?? undefined;
+    }
+    /**
+     * Set a global tag
+     */
+    setTag(key, value) {
+        this.globalTags[key] = value;
+    }
+    /**
+     * Set multiple tags
+     */
+    setTags(tags) {
+        Object.assign(this.globalTags, tags);
+    }
+    /**
+     * Set extra context
+     */
+    setExtra(key, value) {
+        this.globalExtra[key] = value;
+    }
+    /**
+     * Set multiple extra values
+     */
+    setExtras(extras) {
+        Object.assign(this.globalExtra, extras);
+    }
+    /**
+     * Clear breadcrumbs
+     */
+    clearBreadcrumbs() {
+        this.breadcrumbs = [];
+    }
+    // ============================================
+    // Performance Monitoring
+    // ============================================
+    /**
+     * Start a transaction for performance monitoring
+     */
+    startTransaction(options) {
+        if (!this.options.enableTracing || !this.shouldSample(this.options.tracesSampleRate)) {
+            return null;
+        }
+        const transaction = {
+            trace_id: this.generateTraceId(),
+            span_id: this.generateSpanId(),
+            name: options.name,
+            op: options.op,
+            status: 'ok',
+            start_timestamp: Date.now() / 1000,
+            tags: options.tags,
+            data: options.data,
+            spans: []
+        };
+        this.activeTransactions.set(transaction.span_id, transaction);
+        return transaction;
+    }
+    /**
+     * Start a child span within a transaction
+     */
+    startSpan(transaction, options) {
+        const span = {
+            trace_id: transaction.trace_id,
+            span_id: this.generateSpanId(),
+            parent_span_id: transaction.span_id,
+            op: options.op,
+            description: options.description,
+            start_timestamp: Date.now() / 1000,
+            tags: options.tags,
+            data: options.data
+        };
+        transaction.spans = transaction.spans ?? [];
+        transaction.spans.push(span);
+        return span;
+    }
+    /**
+     * Finish a span
+     */
+    finishSpan(span, status) {
+        span.timestamp = Date.now() / 1000;
+        span.status = status ?? 'ok';
+    }
+    /**
+     * Finish a transaction and send to Sentry
+     */
+    finishTransaction(transaction, status) {
+        transaction.timestamp = Date.now() / 1000;
+        transaction.status = status ?? 'ok';
+        this.activeTransactions.delete(transaction.span_id);
+        const processedTx = this.options.beforeSendTransaction(transaction);
+        if (!processedTx) {
+            this.log('Transaction dropped by beforeSendTransaction');
+            return;
+        }
+        this.sendTransaction(processedTx);
+    }
+    // ============================================
+    // Event Building
+    // ============================================
+    buildErrorEvent(error, eventId, options) {
+        const stacktrace = this.parseStackTrace(error);
+        return {
+            event_id: eventId,
+            timestamp: Date.now() / 1000,
+            platform: 'node',
+            level: options.level ?? 'error',
+            logger: 'nexus',
+            server_name: this.options.serverName,
+            release: this.options.release,
+            environment: this.options.environment,
+            exception: {
+                values: [{
+                        type: error.name || 'Error',
+                        value: error.message,
+                        stacktrace,
+                        mechanism: {
+                            type: 'generic',
+                            handled: true
+                        }
+                    }]
+            },
+            user: options.user ?? this.user,
+            tags: { ...this.globalTags, ...options.tags },
+            extra: {
+                ...this.globalExtra,
+                ...options.extra,
+                ...(error.cause ? { cause: String(error.cause) } : {})
+            },
+            contexts: {
+                runtime: {
+                    name: 'node',
+                    version: process.version
+                },
+                os: {
+                    name: process.platform,
+                    version: process.arch
+                },
+                ...options.contexts
+            },
+            breadcrumbs: [...this.breadcrumbs],
+            fingerprint: options.fingerprint
+        };
+    }
+    parseStackTrace(error) {
+        if (!error.stack)
+            return undefined;
+        const lines = error.stack.split('\n').slice(1);
+        const frames = [];
+        for (const line of lines) {
+            const match = line.match(/^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+            if (match) {
+                frames.unshift({
+                    function: match[1] || '<anonymous>',
+                    filename: match[2],
+                    abs_path: match[2],
+                    lineno: parseInt(match[3], 10),
+                    colno: parseInt(match[4], 10),
+                    in_app: !match[2].includes('node_modules')
+                });
+            }
+        }
+        return { frames };
+    }
+    // ============================================
+    // HTTP Transport
+    // ============================================
+    async sendEvent(event) {
+        const envelope = this.buildEnvelope(event, 'event');
+        await this.sendEnvelope(envelope);
+    }
+    async sendTransaction(transaction) {
+        const envelope = this.buildTransactionEnvelope(transaction);
+        await this.sendEnvelope(envelope);
+    }
+    buildEnvelope(event, type) {
+        const header = JSON.stringify({
+            event_id: event.event_id,
+            sent_at: new Date().toISOString(),
+            dsn: this.options.dsn
+        });
+        const itemHeader = JSON.stringify({
+            type,
+            content_type: 'application/json'
+        });
+        const payload = JSON.stringify(event);
+        return `${header}\n${itemHeader}\n${payload}`;
+    }
+    buildTransactionEnvelope(transaction) {
+        const header = JSON.stringify({
+            event_id: this.generateEventId(),
+            sent_at: new Date().toISOString(),
+            dsn: this.options.dsn
+        });
+        const itemHeader = JSON.stringify({
+            type: 'transaction',
+            content_type: 'application/json'
+        });
+        const payload = JSON.stringify({
+            ...transaction,
+            type: 'transaction',
+            platform: 'node',
+            environment: this.options.environment,
+            release: this.options.release,
+            server_name: this.options.serverName,
+            contexts: {
+                trace: {
+                    trace_id: transaction.trace_id,
+                    span_id: transaction.span_id,
+                    parent_span_id: transaction.parent_span_id,
+                    op: transaction.op
+                }
+            }
+        });
+        return `${header}\n${itemHeader}\n${payload}`;
+    }
+    async sendEnvelope(envelope) {
+        const endpoint = this.getEnvelopeEndpoint();
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-sentry-envelope',
+                    'X-Sentry-Auth': this.buildAuthHeader()
+                },
+                body: envelope,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                this.log(`Failed to send event: ${response.status} ${response.statusText}`);
+            }
+            else {
+                this.log('Event sent successfully');
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                this.log('Request timed out');
+            }
+            else {
+                this.log(`Failed to send event: ${error.message}`);
+            }
+        }
+    }
+    buildAuthHeader() {
+        return `Sentry sentry_version=7,sentry_client=nexus-sentry/1.0.0,sentry_key=${this.dsn.publicKey}`;
+    }
+    // ============================================
+    // Helpers
+    // ============================================
+    generateEventId() {
+        return (0, crypto_1.randomUUID)().replace(/-/g, '');
+    }
+    generateTraceId() {
+        return (0, crypto_1.randomUUID)().replace(/-/g, '');
+    }
+    generateSpanId() {
+        return (0, crypto_1.randomUUID)().replace(/-/g, '').substring(0, 16);
+    }
+    shouldSample(rate) {
+        return Math.random() < rate;
+    }
+    shouldIgnoreError(error) {
+        const message = error.message;
+        for (const pattern of this.options.ignoreErrors) {
+            if (typeof pattern === 'string') {
+                if (message.includes(pattern))
+                    return true;
+            }
+            else {
+                if (pattern.test(message))
+                    return true;
+            }
+        }
+        return false;
+    }
+    log(message, data) {
+        if (this.options.debug) {
+            console.log(`[Sentry] ${message}`, data ?? '');
+        }
+    }
+    /**
+     * Enable/disable Sentry
+     */
+    setEnabled(enabled) {
+        this.isEnabled = enabled;
+    }
+    /**
+     * Get current state
+     */
+    isInitialized() {
+        return this.isEnabled;
+    }
+    /**
+     * Flush pending events (useful before shutdown)
+     */
+    async flush(timeout) {
+        // In a more complete implementation, this would wait for pending requests
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(true), timeout ?? 2000);
+        });
+    }
+    /**
+     * Close the client
+     */
+    async close(timeout) {
+        this.apm.stop();
+        await this.flush(timeout);
+        this.isEnabled = false;
+        return true;
+    }
+    // ============================================
+    // APM Methods
+    // ============================================
+    /**
+     * Record a database/external query for slow query tracking
+     *
+     * @example
+     * ```typescript
+     * const start = Date.now();
+     * const result = await db.query('SELECT * FROM users');
+     * sentry.recordQuery('SELECT * FROM users', Date.now() - start);
+     * ```
+     */
+    recordQuery(query, durationMs, metadata) {
+        this.apm.recordQuery(query, durationMs, metadata);
+    }
+    /**
+     * Get all recorded slow queries
+     */
+    getSlowQueries() {
+        return this.apm.getSlowQueries();
+    }
+    /**
+     * Get current memory statistics
+     */
+    getMemoryStats() {
+        return this.apm.getMemoryStats();
+    }
+    /**
+     * Get APM integration instance for advanced usage
+     */
+    getAPM() {
+        return this.apm;
+    }
+}
+exports.SentryClient = SentryClient;
+/**
+ * Create Sentry middleware for Nexus
+ */
+function createSentryMiddleware(client, options = {}) {
+    const { includeRequestBody = false, includeHeaders = true, excludeHeaders = ['authorization', 'cookie', 'x-api-key'], ignorePaths = [], extractUser = () => null, getTransactionName = (ctx) => `${ctx.method} ${ctx.path}` } = options;
+    return async (ctx, next, _deps) => {
+        // Check if path should be ignored
+        if (ignorePaths.some(p => ctx.path.startsWith(p))) {
+            return next(ctx);
+        }
+        // Add breadcrumb for request
+        client.addBreadcrumb({
+            type: 'http',
+            category: 'http.request',
+            message: `${ctx.method} ${ctx.path}`,
+            data: {
+                method: ctx.method,
+                url: ctx.path,
+                query: ctx.query
+            },
+            level: 'info'
+        });
+        // Set user context
+        const user = extractUser(ctx);
+        if (user) {
+            client.setUser({
+                ...user,
+                ip_address: ctx.headers['x-forwarded-for'] || ctx.headers['x-real-ip']
+            });
+        }
+        // Start transaction for performance monitoring
+        const transaction = client.startTransaction({
+            name: getTransactionName(ctx),
+            op: 'http.server',
+            tags: {
+                'http.method': ctx.method,
+                'http.url': ctx.path
+            }
+        });
+        // Store transaction in context for child spans
+        if (transaction) {
+            ctx.sentryTransaction = transaction;
+            ctx.sentryClient = client;
+        }
+        const startTime = Date.now();
+        try {
+            const response = await next(ctx);
+            // Finish transaction with success
+            if (transaction) {
+                transaction.data = {
+                    ...transaction.data,
+                    'http.status_code': response.statusCode,
+                    'http.response_time_ms': Date.now() - startTime
+                };
+                client.finishTransaction(transaction, response.statusCode >= 500 ? 'internal_error' : 'ok');
+            }
+            // Add response breadcrumb
+            client.addBreadcrumb({
+                type: 'http',
+                category: 'http.response',
+                message: `${ctx.method} ${ctx.path} - ${response.statusCode}`,
+                data: {
+                    status_code: response.statusCode,
+                    duration_ms: Date.now() - startTime
+                },
+                level: response.statusCode >= 400 ? 'warning' : 'info'
+            });
+            return response;
+        }
+        catch (error) {
+            // Build request context
+            const requestData = {
+                url: ctx.url?.toString(),
+                method: ctx.method,
+                query_string: ctx.url?.search
+            };
+            if (includeHeaders) {
+                const headers = {};
+                for (const [key, value] of Object.entries(ctx.headers)) {
+                    if (!excludeHeaders.includes(key.toLowerCase())) {
+                        headers[key] = Array.isArray(value) ? value.join(', ') : (value ?? '');
+                    }
+                }
+                requestData.headers = headers;
+            }
+            if (includeRequestBody && ctx.body) {
+                requestData.data = ctx.body;
+            }
+            // Capture the exception
+            client.captureException(error, {
+                tags: {
+                    'http.method': ctx.method,
+                    'http.url': ctx.path
+                },
+                extra: {
+                    request: requestData,
+                    params: ctx.params,
+                    query: ctx.query
+                },
+                user: user ?? undefined
+            });
+            // Finish transaction with error
+            if (transaction) {
+                client.finishTransaction(transaction, 'internal_error');
+            }
+            throw error;
+        }
+    };
+}
+// ============================================
+// Request Handler Error Wrapper
+// ============================================
+/**
+ * Create an error handler that reports to Sentry
+ */
+function createSentryErrorHandler(client) {
+    return (error, ctx) => {
+        client.captureException(error, {
+            tags: {
+                'http.method': ctx.method,
+                'http.url': ctx.path
+            },
+            extra: {
+                params: ctx.params,
+                query: ctx.query
+            }
+        });
+        return {
+            statusCode: 500,
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                error: 'Internal Server Error',
+                message: process.env.NODE_ENV === 'development' ? error.message : undefined
+            })
+        };
+    };
+}
+// ============================================
+// Helper Functions
+// ============================================
+/**
+ * Create a child span in the current transaction
+ */
+function withSpan(ctx, options, fn) {
+    const client = ctx.sentryClient;
+    const transaction = ctx.sentryTransaction;
+    if (!client || !transaction) {
+        return fn();
+    }
+    const span = client.startSpan(transaction, options);
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            return result.then((value) => {
+                client.finishSpan(span, 'ok');
+                return value;
+            }, (error) => {
+                client.finishSpan(span, 'internal_error');
+                throw error;
+            });
+        }
+        client.finishSpan(span, 'ok');
+        return result;
+    }
+    catch (error) {
+        client.finishSpan(span, 'internal_error');
+        throw error;
+    }
+}
+// ============================================
+// Factory Functions
+// ============================================
+let globalClient = null;
+/**
+ * Initialize Sentry
+ */
+function initSentry(options) {
+    globalClient = new SentryClient(options);
+    return globalClient;
+}
+/**
+ * Get the global Sentry client
+ */
+function getSentry() {
+    return globalClient;
+}
+/**
+ * Capture exception using global client
+ */
+function captureException(error, options) {
+    if (!globalClient) {
+        console.warn('[Sentry] Client not initialized. Call initSentry() first.');
+        return '';
+    }
+    return globalClient.captureException(error, options);
+}
+/**
+ * Capture message using global client
+ */
+function captureMessage(message, options) {
+    if (!globalClient) {
+        console.warn('[Sentry] Client not initialized. Call initSentry() first.');
+        return '';
+    }
+    return globalClient.captureMessage(message, options);
+}
+/**
+ * Add breadcrumb using global client
+ */
+function addBreadcrumb(breadcrumb) {
+    globalClient?.addBreadcrumb(breadcrumb);
+}
+/**
+ * Set user using global client
+ */
+function setUser(user) {
+    globalClient?.setUser(user);
+}
+/**
+ * Set tag using global client
+ */
+function setTag(key, value) {
+    globalClient?.setTag(key, value);
+}
+/**
+ * Set extra using global client
+ */
+function setExtra(key, value) {
+    globalClient?.setExtra(key, value);
+}
+/**
+ * Create Sentry plugin for Nexus
+ *
+ * @example
+ * ```typescript
+ * import { sentry } from './src/advanced/sentry';
+ *
+ * app.plugin(sentry({
+ *   dsn: 'https://xxx@xxx.ingest.sentry.io/xxx',
+ *   environment: 'production',
+ *   tracesSampleRate: 0.1,
+ *   middleware: {
+ *     includeRequestBody: true,
+ *     ignorePaths: ['/health', '/metrics']
+ *   }
+ * }));
+ * ```
+ */
+function sentry(options) {
+    return {
+        name: 'sentry',
+        version: '1.0.0',
+        install(app) {
+            // Initialize Sentry client
+            const client = initSentry(options);
+            // Add middleware
+            app.use(createSentryMiddleware(client, options.middleware));
+            // Wrap error handler to capture exceptions
+            const originalOnError = app.onError.bind(app);
+            app.onError((error, ctx) => {
+                client.captureException(error, {
+                    tags: {
+                        'http.method': ctx.method,
+                        'http.url': ctx.path
+                    },
+                    extra: {
+                        params: ctx.params,
+                        query: ctx.query
+                    }
+                });
+                // Return default error response
+                return {
+                    statusCode: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        error: 'Internal Server Error',
+                        message: process.env.NODE_ENV === 'development' ? error.message : undefined
+                    })
+                };
+            });
+            // Add shutdown hook if graceful shutdown is enabled
+            if (typeof app.onShutdown === 'function') {
+                app.onShutdown('sentry-flush', async () => {
+                    await client.flush(5000);
+                }, 1);
+            }
+        }
+    };
+}
+//# sourceMappingURL=index.js.map