upshift-config 0.5.14

package/lib/core/analytics/instrumentation.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMethodTracking = withMethodTracking;
+exports.withSyncMethodTracking = withSyncMethodTracking;
+exports.instrumentClass = instrumentClass;
+const chain_name_1 = require("./chain-name");
+const method_taxonomy_1 = require("./method-taxonomy");
+const sanitize_1 = require("./sanitize");
+const sentry_runtime_1 = require("./sentry-runtime");
+const sentry_1 = require("./sentry");
+/**
+ * Higher-order function to wrap SDK methods with performance tracking.
+ * Tracks method calls, timing, chain usage, and errors.
+ *
+ * @param methodName - Name of the method being wrapped
+ * @param method - The original async method
+ * @param getChainId - Function to get current chain ID
+ * @returns Wrapped method with tracking
+ */
+function withMethodTracking(methodName, method, getChainId) {
+    return async function trackedMethod(...args) {
+        if (!(0, sentry_1.isAnalyticsEnabled)()) {
+            return method(...args);
+        }
+        // Resolve the SDK before the sanitize/shape/category work — when
+        // @sentry/node fails to resolve, every call would otherwise pay the
+        // hot-path cost only to discard the result below.
+        const sdk = (0, sentry_runtime_1.getSentrySDK)();
+        if (!sdk) {
+            return method(...args);
+        }
+        const startTime = performance.now();
+        const chainId = getChainId?.();
+        const category = (0, method_taxonomy_1.getMethodCategory)(methodName);
+        const sanitizedArgs = (0, sanitize_1.sanitizeArgs)(args);
+        const argShape = (0, sanitize_1.computeArgShape)(args);
+        try {
+            // Use Sentry's startSpan for performance tracking (v8 API)
+            return await sdk.startSpan({
+                op: 'sdk.method',
+                name: methodName,
+                attributes: {
+                    chainId: chainId?.toString() || 'unknown',
+                    'sdk.chain': (0, chain_name_1.chainIdToTagValue)(chainId),
+                    'sdk.category': category,
+                    // Joined to a string because Sentry span attributes are scalar.
+                    'sdk.argShape': argShape.join('|'),
+                    ...sanitizedArgs,
+                },
+            }, async (span) => {
+                try {
+                    const result = await method(...args);
+                    const duration = performance.now() - startTime;
+                    // Record success metrics
+                    span?.setAttribute('duration', Math.round(duration));
+                    span?.setAttribute('success', true);
+                    // Track method call
+                    trackMethodCall(methodName, {
+                        method: methodName,
+                        category,
+                        chainId,
+                        duration,
+                        success: true,
+                    }, { ...sanitizedArgs, argShape: argShape.join('|') });
+                    span?.setStatus({ code: 1 }); // OK status
+                    return result;
+                }
+                catch (error) {
+                    const duration = performance.now() - startTime;
+                    const errorType = error instanceof Error ? error.name : 'UnknownError';
+                    // Record error metrics
+                    span?.setAttribute('duration', Math.round(duration));
+                    span?.setAttribute('success', false);
+                    span?.setAttribute('error', error instanceof Error ? error.message : String(error));
+                    // Track failed method call
+                    trackMethodCall(methodName, {
+                        method: methodName,
+                        category,
+                        chainId,
+                        duration,
+                        success: false,
+                        errorType,
+                    }, { ...sanitizedArgs, argShape: argShape.join('|') });
+                    span?.setStatus({ code: 2, message: errorType }); // Error status
+                    throw error;
+                }
+            });
+        }
+        catch (error) {
+            // If Sentry.startSpan fails, fall back to direct method call
+            // This ensures analytics never breaks SDK functionality
+            if (error instanceof Error && error.message?.includes('Sentry')) {
+                return method(...args);
+            }
+            // Re-throw the original method error
+            throw error;
+        }
+    };
+}
+/**
+ * Track individual method calls as breadcrumbs and measurements.
+ */
+function trackMethodCall(methodName, metrics, args) {
+    try {
+        const sdk = (0, sentry_runtime_1.getSentrySDK)();
+        if (!sdk)
+            return;
+        // Add breadcrumb for method call
+        sdk.addBreadcrumb({
+            category: 'sdk.method',
+            message: methodName,
+            level: metrics.success ? 'info' : 'error',
+            data: {
+                chainId: metrics.chainId,
+                category: metrics.category,
+                duration: Math.round(metrics.duration),
+                errorType: metrics.errorType,
+                ...args,
+            },
+        });
+        // Set measurement for method duration
+        sdk.setMeasurement('sdk.method.duration', metrics.duration, 'millisecond');
+        // Counters: SUM(invocation) → total calls; SUM(error)/SUM(invocation) → error rate.
+        sdk.setMeasurement('sdk.method.invocation', 1, 'none');
+        sdk.setMeasurement('sdk.method.error', metrics.success ? 0 : 1, 'none');
+        // Only sticky-tag the last method name — useful for attributing errors that fire
+        // outside an active SDK span. sdk.category and sdk.chain are already recorded as
+        // span attributes on each call, so mutating the global scope with them here would
+        // just contaminate subsequent unrelated events with stale values.
+        sdk.setTag('sdk.last_method', methodName);
+    }
+    catch {
+        // Silently fail - analytics should never break SDK
+    }
+}
+/**
+ * Check if a function is async (returns a Promise).
+ */
+function isAsyncMethod(fn) {
+    // Check if constructor name indicates async
+    if (fn.constructor.name === 'AsyncFunction') {
+        return true;
+    }
+    // Check if function body suggests async
+    const fnString = fn.toString();
+    return fnString.includes('__awaiter') || fnString.startsWith('async');
+}
+/**
+ * Higher-order function to wrap synchronous SDK methods with tracking.
+ * Uses breadcrumbs for tracking since spans require async context.
+ *
+ * @param methodName - Name of the method being wrapped
+ * @param method - The original sync method
+ * @param getChainId - Function to get current chain ID
+ * @returns Wrapped method with tracking
+ */
+function withSyncMethodTracking(methodName, method, getChainId) {
+    return function trackedSyncMethod(...args) {
+        if (!(0, sentry_1.isAnalyticsEnabled)()) {
+            return method(...args);
+        }
+        // Same hot-path short-circuit as the async path.
+        const sdk = (0, sentry_runtime_1.getSentrySDK)();
+        if (!sdk) {
+            return method(...args);
+        }
+        const startTime = performance.now();
+        const chainId = getChainId?.();
+        const category = (0, method_taxonomy_1.getMethodCategory)(methodName);
+        const sanitizedArgs = (0, sanitize_1.sanitizeArgs)(args);
+        const argShape = (0, sanitize_1.computeArgShape)(args);
+        try {
+            const result = method(...args);
+            const duration = performance.now() - startTime;
+            // Track successful sync method call via breadcrumb
+            trackSyncMethodCall(methodName, {
+                method: methodName,
+                category,
+                chainId,
+                duration,
+                success: true,
+            }, { ...sanitizedArgs, argShape: argShape.join('|') });
+            return result;
+        }
+        catch (error) {
+            const duration = performance.now() - startTime;
+            const errorType = error instanceof Error ? error.name : 'UnknownError';
+            // Track failed sync method call
+            trackSyncMethodCall(methodName, {
+                method: methodName,
+                category,
+                chainId,
+                duration,
+                success: false,
+                errorType,
+            }, { ...sanitizedArgs, argShape: argShape.join('|') });
+            throw error;
+        }
+    };
+}
+/**
+ * Track synchronous method calls as breadcrumbs.
+ */
+function trackSyncMethodCall(methodName, metrics, args) {
+    try {
+        const sdk = (0, sentry_runtime_1.getSentrySDK)();
+        if (!sdk)
+            return;
+        // Add breadcrumb for sync method call
+        sdk.addBreadcrumb({
+            category: 'sdk.sync_method',
+            message: methodName,
+            level: metrics.success ? 'info' : 'error',
+            data: {
+                chainId: metrics.chainId,
+                category: metrics.category,
+                duration: Math.round(metrics.duration),
+                errorType: metrics.errorType,
+                ...args,
+            },
+        });
+        // Measurements omitted: sync methods have no span of their own, so setMeasurement
+        // would attach to whatever parent transaction happens to be active on the scope,
+        // overwriting its counters. The breadcrumb above already captures success/failure.
+        sdk.setTag('sdk.last_sync_method', methodName);
+        if (metrics.category) {
+            sdk.setTag('sdk.category', metrics.category);
+        }
+        if (metrics.chainId !== undefined) {
+            sdk.setTag('sdk.chain', (0, chain_name_1.chainIdToTagValue)(metrics.chainId));
+            sdk.setTag('sdk.last_chainId', metrics.chainId.toString());
+        }
+    }
+    catch {
+        // Silently fail - analytics should never break SDK
+    }
+}
+/**
+ * Instrument all methods on a class instance with tracking.
+ * This auto-wraps all public methods (both async and sync) without boilerplate.
+ *
+ * @param instance - The class instance to instrument
+ * @param getChainId - Function to get current chain ID
+ * @returns The same instance with instrumented methods
+ */
+function instrumentClass(instance, getChainId) {
+    try {
+        const proto = Object.getPrototypeOf(instance);
+        const methodNames = Object.getOwnPropertyNames(proto).filter((name) => {
+            // Skip constructor and private methods
+            if (name === 'constructor' || name.startsWith('_'))
+                return false;
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            return typeof descriptor?.value === 'function';
+        });
+        for (const methodName of methodNames) {
+            const original = instance[methodName];
+            if (typeof original === 'function') {
+                if (isAsyncMethod(original)) {
+                    // Wrap async methods with span-based tracking
+                    instance[methodName] =
+                        withMethodTracking(methodName, original.bind(instance), getChainId);
+                }
+                else {
+                    // Wrap sync methods with breadcrumb-based tracking
+                    instance[methodName] =
+                        withSyncMethodTracking(methodName, original.bind(instance), getChainId);
+                }
+            }
+        }
+    }
+    catch {
+        // Silently fail - analytics should never break SDK
+    }
+    return instance;
+}
+//# sourceMappingURL=instrumentation.js.map

package/lib/core/analytics/method-taxonomy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Canonical category for an SDK public method, used as the `sdk.category`
+ * Sentry tag so the partner-usage dashboard can roll calls up into
+ * `read.*` / `write.*` / `network` / `bridge` buckets.
+ */
+export type MethodCategory = 'read.vault' | 'read.position' | 'read.redemption' | 'read.price' | 'read.points' | 'read.subaccount' | 'read.staking' | 'read.layerzero' | 'read.solana' | 'read.stellar' | 'read.sui' | 'read.evm' | 'write.deposit' | 'write.redeem' | 'write.approve' | 'write.points' | 'write.stellar' | 'network' | 'bridge' | 'unknown';
+/**
+ * Map of public SDK method names to their {@link MethodCategory}.
+ *
+ * Keys are unqualified because `instrumentClass` walks the prototype and
+ * surfaces them that way; the same name on multiple adapters (e.g.
+ * `vaultDeposit` on EVM, Solana, Stellar) shares the same category.
+ */
+export declare const METHOD_CATEGORIES: Readonly<Record<string, MethodCategory>>;
+/**
+ * Look up the category for a method name, defaulting to `'unknown'` for
+ * methods not yet added to {@link METHOD_CATEGORIES}.
+ */
+export declare function getMethodCategory(methodName: string): MethodCategory;

package/lib/core/analytics/method-taxonomy.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METHOD_CATEGORIES = void 0;
+exports.getMethodCategory = getMethodCategory;
+/**
+ * Map of public SDK method names to their {@link MethodCategory}.
+ *
+ * Keys are unqualified because `instrumentClass` walks the prototype and
+ * surfaces them that way; the same name on multiple adapters (e.g.
+ * `vaultDeposit` on EVM, Solana, Stellar) shares the same category.
+ */
+exports.METHOD_CATEGORIES = {
+    getVault: 'read.vault',
+    getVaults: 'read.vault',
+    getTotalDeposited: 'read.vault',
+    getVaultLoans: 'read.vault',
+    getVaultSubaccountLoans: 'read.vault',
+    getVaultAllocations: 'read.vault',
+    getVaultApy: 'read.vault',
+    getVaultAnnualizedApy: 'read.vault',
+    getVaultTvl: 'read.vault',
+    getVaultHistoricalTimeseries: 'read.vault',
+    getVaultSummary: 'read.vault',
+    getVaultPnl: 'read.vault',
+    getVaultUnrealizedPnlHistory: 'read.vault',
+    getLatestUnrealizedPnl: 'read.vault',
+    getDashboardLoans: 'read.vault',
+    getDiscountFactors: 'read.vault',
+    getCollateralExcessOrDeficit: 'read.vault',
+    simulateCollateral: 'read.vault',
+    getRevertReason: 'read.vault',
+    getOtcPositions: 'read.vault',
+    getOtcMarginRequirements: 'read.vault',
+    getCuratorVaultSubaccounts: 'read.vault',
+    getCuratorVaultWhitelist: 'read.vault',
+    getTimelockRequests: 'read.vault',
+    getVaultPerformanceFees: 'read.vault',
+    getVaultOracleClassification: 'read.vault',
+    getVaultBorrowerHealthFactor: 'read.vault',
+    getYieldLastRealizedOn: 'read.vault',
+    getVaultActivity: 'read.vault',
+    getSwapRouterDepositResult: 'read.vault',
+    getSwapRouterWhitelistedTokens: 'read.vault',
+    getSwapRouterEligibleVaults: 'read.vault',
+    getVaultPositions: 'read.position',
+    getVaultUserHistory: 'read.position',
+    getUserHistory: 'read.position',
+    getVaultUserTransfers: 'read.position',
+    getUserTransfers: 'read.position',
+    getVaultUserLifetimePnl: 'read.position',
+    getVaultAvailableRedemptions: 'read.redemption',
+    getVaultRedemptionHistory: 'read.redemption',
+    getVaultPendingRedemptions: 'read.redemption',
+    getVaultWithdrawals: 'read.redemption',
+    getWithdrawalRequestsWithStatus: 'read.redemption',
+    previewRedemption: 'read.redemption',
+    getPrice: 'read.price',
+    getUserPoints: 'read.points',
+    fetchPointsLeaderboard: 'read.points',
+    getAllSubaccounts: 'read.subaccount',
+    getSubaccountHealthFactor: 'read.subaccount',
+    getSubaccountLoans: 'read.subaccount',
+    getSubaccountCefiPositions: 'read.subaccount',
+    getSubaccountOtcPositions: 'read.subaccount',
+    getSubaccountSummary: 'read.subaccount',
+    getSubaccountTransactions: 'read.subaccount',
+    getSubaccountLoanByAddress: 'read.subaccount',
+    getSubaccountDebank: 'read.subaccount',
+    getStakingPositions: 'read.staking',
+    getVaultStakingPositions: 'read.staking',
+    getLayerZeroDeposits: 'read.layerzero',
+    getLayerZeroRedeems: 'read.layerzero',
+    getVaultState: 'read.solana',
+    getVaultStateReadOnly: 'read.solana',
+    getToken: 'read.solana',
+    getTokenSymbol: 'read.solana',
+    fetchUserTokenBalance: 'read.solana',
+    fetchUserShareBalance: 'read.solana',
+    fetchUserShareBalanceRaw: 'read.solana',
+    // Both are offline resolvers (no RPC) — classified so the partner dashboard
+    // sees program-targeting calls instead of dropping them into 'unknown'.
+    getProgram: 'read.solana',
+    getProgramId: 'read.solana',
+    // submitTransaction broadcasts a signed Soroban tx — it mutates on-chain
+    // state and belongs in the write bucket even though Stellar adapter call
+    // shape mirrors the read helpers (returns a hash, takes signed XDR).
+    submitTransaction: 'write.stellar',
+    getUserPosition: 'read.stellar',
+    // convertToShares is a read-only Soroban simulation despite its mutative-
+    // sounding name — runs through queryContract, no broadcast.
+    convertToShares: 'read.stellar',
+    getEmberVaults: 'read.sui',
+    getEmberTVL: 'read.sui',
+    vaultAllowance: 'read.evm',
+    sendersWhitelistAddress: 'read.evm',
+    isWhitelisted: 'read.evm',
+    getDeposited: 'read.evm',
+    getRemainingAllocations: 'read.evm',
+    previewDeposit: 'read.vault',
+    previewRedeem: 'read.redemption',
+    allowance: 'read.evm',
+    balanceOf: 'read.evm',
+    maxDeposit: 'read.vault',
+    vaultDeposit: 'write.deposit',
+    depositNative: 'write.deposit',
+    swapAndDeposit: 'write.deposit',
+    depositViaSwapRouter: 'write.deposit',
+    depositNativeViaSwapRouter: 'write.deposit',
+    swapRouterDeposit: 'write.deposit',
+    vaultRedeem: 'write.redeem',
+    vaultRequestRedeem: 'write.redeem',
+    rwaRedeemAsset: 'write.redeem',
+    vaultApprove: 'write.approve',
+    approve: 'write.approve',
+    registerUserForPoints: 'write.points',
+    switchNetwork: 'network',
+    updateWallet: 'network',
+    clearWallet: 'network',
+    setSigner: 'network',
+};
+/**
+ * Look up the category for a method name, defaulting to `'unknown'` for
+ * methods not yet added to {@link METHOD_CATEGORIES}.
+ */
+function getMethodCategory(methodName) {
+    return exports.METHOD_CATEGORIES[methodName] ?? 'unknown';
+}
+//# sourceMappingURL=method-taxonomy.js.map

package/lib/core/analytics/metrics.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Aggregated cache statistics for monitoring.
+ */
+declare let cacheStats: {
+    hits: number;
+    misses: number;
+    sets: number;
+};
+/**
+ * Track API response times and status.
+ *
+ * @param endpoint - The API endpoint called
+ * @param method - HTTP method used
+ * @param startTime - Start timestamp from performance.now()
+ * @param status - HTTP response status code (0 for network errors)
+ * @param server - Server identifier (production, staging, etc.)
+ */
+export declare function trackApiCall(endpoint: string, method: string, startTime: number, status: number, server: string): void;
+/**
+ * Track chain/network switches for usage distribution analysis.
+ *
+ * @param chainId - The chain ID being switched to
+ */
+export declare function trackNetworkSwitch(chainId: number): void;
+/**
+ * Get current cache statistics.
+ */
+export declare function getCacheStats(): typeof cacheStats;
+/**
+ * Reset cache statistics (useful for testing).
+ */
+export declare function resetCacheStats(): void;
+export {};

package/lib/core/analytics/metrics.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackApiCall = trackApiCall;
+exports.trackNetworkSwitch = trackNetworkSwitch;
+exports.getCacheStats = getCacheStats;
+exports.resetCacheStats = resetCacheStats;
+const chain_name_1 = require("./chain-name");
+const sentry_runtime_1 = require("./sentry-runtime");
+const sentry_1 = require("./sentry");
+/**
+ * Aggregated cache statistics for monitoring.
+ */
+let cacheStats = {
+    hits: 0,
+    misses: 0,
+    sets: 0,
+};
+/**
+ * Track API response times and status.
+ *
+ * @param endpoint - The API endpoint called
+ * @param method - HTTP method used
+ * @param startTime - Start timestamp from performance.now()
+ * @param status - HTTP response status code (0 for network errors)
+ * @param server - Server identifier (production, staging, etc.)
+ */
+function trackApiCall(endpoint, method, startTime, status, server) {
+    if (!(0, sentry_1.isAnalyticsEnabled)())
+        return;
+    try {
+        const sdk = (0, sentry_runtime_1.getSentrySDK)();
+        if (!sdk)
+            return;
+        const duration = performance.now() - startTime;
+        // Normalize endpoint for aggregation (replace dynamic segments)
+        const normalizedEndpoint = normalizeEndpoint(endpoint);
+        // Add breadcrumb
+        sdk.addBreadcrumb({
+            category: 'api',
+            message: `${method} ${normalizedEndpoint}`,
+            level: status >= 400 || status === 0 ? 'error' : 'info',
+            data: {
+                endpoint: normalizedEndpoint,
+                method,
+                duration: Math.round(duration),
+                status,
+                server,
+            },
+        });
+        // Set measurement for performance tracking
+        sdk.setMeasurement('api.duration', duration, 'millisecond');
+        // Update tags for filtering
+        sdk.setTag('api.last_endpoint', normalizedEndpoint);
+        sdk.setTag('api.server', server);
+    }
+    catch {
+        // Silently fail - analytics should never break SDK
+    }
+}
+/**
+ * Track chain/network switches for usage distribution analysis.
+ *
+ * @param chainId - The chain ID being switched to
+ */
+function trackNetworkSwitch(chainId) {
+    if (!(0, sentry_1.isAnalyticsEnabled)())
+        return;
+    try {
+        const sdk = (0, sentry_runtime_1.getSentrySDK)();
+        if (!sdk)
+            return;
+        const chainLabel = (0, chain_name_1.chainIdToTagValue)(chainId);
+        sdk.addBreadcrumb({
+            category: 'network',
+            message: `Switched to chain ${chainId} (${chainLabel})`,
+            level: 'info',
+            data: { chainId, chain: chainLabel },
+        });
+        sdk.setTag('active.chainId', chainId.toString());
+        sdk.setTag('sdk.chain', chainLabel);
+    }
+    catch {
+        // Silently fail - analytics should never break SDK
+    }
+}
+/**
+ * Normalize endpoint URLs for aggregation.
+ * Replaces dynamic segments (addresses, IDs) with placeholders.
+ *
+ * @param endpoint - Raw endpoint URL
+ * @returns Normalized endpoint pattern
+ */
+function normalizeEndpoint(endpoint) {
+    return (endpoint
+        // Replace Ethereum addresses (0x + 40 hex chars)
+        .replace(/0x[a-fA-F0-9]{40}/g, ':address')
+        // Replace chain IDs (5+ digit numbers)
+        .replace(/\/\d{5,}/g, '/:chainId')
+        // Replace UUIDs
+        .replace(/[a-f0-9-]{36}/gi, ':uuid')
+        // Replace numeric IDs in paths
+        .replace(/\/\d+(?=\/|$)/g, '/:id'));
+}
+/**
+ * Get current cache statistics.
+ */
+function getCacheStats() {
+    return { ...cacheStats };
+}
+/**
+ * Reset cache statistics (useful for testing).
+ */
+function resetCacheStats() {
+    cacheStats = { hits: 0, misses: 0, sets: 0 };
+}
+//# sourceMappingURL=metrics.js.map

package/lib/core/analytics/sanitize.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Redact secrets from a free-form string (error messages, URLs, log lines).
+ *
+ * @example
+ *   sanitizeString('Request failed: https://api.example.com/v1?api_key=abc123')
+ *   // → 'Request failed: https://api.example.com/v1?api_key=[REDACTED]'
+ */
+export declare function sanitizeString(input: string): string;
+/**
+ * Return a redacted clone of `err`. Preserves prototype (so `instanceof` checks
+ * keep working), `name`, all own properties (`code`, `status`, `correlationId`,
+ * …), and `cause`. Subclass constructors are NOT invoked — they may have
+ * positional signatures (`new AugustAuthError(code, message, opts)`) that would
+ * misalign if we naively passed the sanitized message as the first arg.
+ */
+export declare function sanitizeError(err: unknown): unknown;
+/** Sanitize arbitrary log input (strings, errors, objects, arrays, primitives). */
+export declare function sanitizeForLogging(input: unknown, depth?: number): unknown;
+/**
+ * Compute a value-free structural signature for a list of arguments — used
+ * as the `sdk.argShape` Sentry tag so dashboards can count which overload of
+ * a method partners call without ingesting wallet addresses or other PII.
+ *
+ * Tokens: primitives keep their `typeof` name; 0x-prefixed strings narrow to
+ * `'address'` / `'tx-hash'` / `'hex'`; arrays render as `'array(<length>)'`;
+ * objects render as `'options{<sorted,keys>}'`, capped at 12 keys.
+ *
+ * @param args - The `arguments` array of an instrumented method.
+ * @returns Shape tokens, one per arg, in argument order.
+ *
+ * @example
+ *   computeArgShape(['0xabc…ef', { vault: '0x…', chainId: 1 }])
+ *   // → ['address', 'options{chainId,vault}']
+ */
+export declare function computeArgShape(args: unknown[]): string[];
+/**
+ * Sanitize method arguments for safe logging to Sentry.
+ * Removes sensitive data and truncates large values.
+ */
+export declare function sanitizeArgs(args: unknown[]): Record<string, unknown>;
+/**
+ * Recursively sanitize an object, removing sensitive keys.
+ */
+export declare function sanitizeObject(obj: Record<string, unknown>, depth?: number): Record<string, unknown>;