@stackmemoryai/stackmemory 0.5.52 → 0.5.53

package/scripts/testing/src/core/trace/index.js

@@ -1,120 +0,0 @@
-/**
- * Trace Module Export
- * Central export for all tracing functionality
- */
-export { trace, TraceContext, Trace, TraceClass, TraceCritical, } from './debug-trace.js';
-export { wrapCommand, wrapProgram, traceStep, traceQuery, traceAPI, } from './cli-trace-wrapper.js';
-export { createTracedDatabase, wrapDatabase, getQueryStatistics, createTracedTransaction, } from './db-trace-wrapper.js';
-export { TraceLinearAPI, createTracedFetch, wrapGraphQLClient, } from './linear-api-wrapper.js';
-/**
- * Initialize tracing based on environment configuration
- */
-export function initializeTracing() {
-    const config = {
-        // Main control
-        DEBUG_TRACE: process.env.DEBUG_TRACE === 'true',
-        STACKMEMORY_DEBUG: process.env.STACKMEMORY_DEBUG === 'true',
-        // Output control
-        TRACE_OUTPUT: process.env.TRACE_OUTPUT || 'console', // console|file|both
-        TRACE_VERBOSITY: process.env.TRACE_VERBOSITY || 'full', // full|errors|summary
-        // Content control
-        TRACE_PARAMS: process.env.TRACE_PARAMS !== 'false', // Include parameters
-        TRACE_RESULTS: process.env.TRACE_RESULTS !== 'false', // Include results
-        TRACE_MASK_SENSITIVE: process.env.TRACE_MASK_SENSITIVE !== 'false', // Mask sensitive data
-        // Performance
-        TRACE_PERF_THRESHOLD: parseInt(process.env.TRACE_PERF_THRESHOLD || '100'), // ms
-        TRACE_MEMORY: process.env.TRACE_MEMORY === 'true', // Track memory usage
-        TRACE_MAX_DEPTH: parseInt(process.env.TRACE_MAX_DEPTH || '20'), // Max call depth
-        // Database specific
-        TRACE_DB: process.env.TRACE_DB === 'true', // Enable database tracing
-        TRACE_DB_SLOW: parseInt(process.env.TRACE_DB_SLOW || '100'), // Slow query threshold
-        // API specific
-        TRACE_API: process.env.TRACE_API === 'true', // Enable API tracing
-        TRACE_API_SLOW: parseInt(process.env.TRACE_API_SLOW || '1000'), // Slow API threshold
-    };
-    // Log configuration if debugging is enabled
-    if (config.DEBUG_TRACE || config.STACKMEMORY_DEBUG) {
-        console.log('🔍 Trace Configuration:', {
-            enabled: true,
-            output: config.TRACE_OUTPUT,
-            verbosity: config.TRACE_VERBOSITY,
-            includeParams: config.TRACE_PARAMS,
-            includeResults: config.TRACE_RESULTS,
-            maskSensitive: config.TRACE_MASK_SENSITIVE,
-            performanceThreshold: config.TRACE_PERF_THRESHOLD,
-            captureMemory: config.TRACE_MEMORY,
-            maxDepth: config.TRACE_MAX_DEPTH,
-            database: {
-                enabled: config.TRACE_DB,
-                slowThreshold: config.TRACE_DB_SLOW,
-            },
-            api: {
-                enabled: config.TRACE_API,
-                slowThreshold: config.TRACE_API_SLOW,
-            },
-        });
-    }
-}
-/**
- * Helper to enable tracing for a specific scope
- */
-export function withTracing(fn, options) {
-    const originalEnv = process.env.DEBUG_TRACE;
-    try {
-        // Temporarily enable tracing
-        process.env.DEBUG_TRACE = 'true';
-        // Apply custom options if provided
-        if (options) {
-            if (options.output)
-                process.env.TRACE_OUTPUT = options.output;
-            if (options.verbosity)
-                process.env.TRACE_VERBOSITY = options.verbosity;
-            if (options.includeParams !== undefined) {
-                process.env.TRACE_PARAMS = String(options.includeParams);
-            }
-            if (options.includeResults !== undefined) {
-                process.env.TRACE_RESULTS = String(options.includeResults);
-            }
-            if (options.performanceThreshold !== undefined) {
-                process.env.TRACE_PERF_THRESHOLD = String(options.performanceThreshold);
-            }
-        }
-        return fn();
-    }
-    finally {
-        // Restore original environment
-        if (originalEnv === undefined) {
-            delete process.env.DEBUG_TRACE;
-        }
-        else {
-            process.env.DEBUG_TRACE = originalEnv;
-        }
-    }
-}
-/**
- * Quick enable/disable functions for debugging
- */
-export const enableTracing = () => {
-    process.env.DEBUG_TRACE = 'true';
-    console.log('✅ Tracing enabled');
-};
-export const disableTracing = () => {
-    delete process.env.DEBUG_TRACE;
-    console.log('❌ Tracing disabled');
-};
-export const enableVerboseTracing = () => {
-    process.env.DEBUG_TRACE = 'true';
-    process.env.TRACE_VERBOSITY = 'full';
-    process.env.TRACE_PARAMS = 'true';
-    process.env.TRACE_RESULTS = 'true';
-    process.env.TRACE_MEMORY = 'true';
-    console.log('✅ Verbose tracing enabled');
-};
-export const enableMinimalTracing = () => {
-    process.env.DEBUG_TRACE = 'true';
-    process.env.TRACE_VERBOSITY = 'summary';
-    process.env.TRACE_PARAMS = 'false';
-    process.env.TRACE_RESULTS = 'false';
-    process.env.TRACE_MEMORY = 'false';
-    console.log('✅ Minimal tracing enabled');
-};

package/scripts/testing/src/core/trace/linear-api-wrapper.js

@@ -1,204 +0,0 @@
-/**
- * Linear API Trace Wrapper
- * Wraps Linear API client with comprehensive tracing for debugging
- */
-import { trace } from './debug-trace.js';
-import { logger } from '../monitoring/logger.js';
-/**
- * Decorator to trace Linear API GraphQL calls
- */
-export function TraceLinearAPI(target, propertyKey, descriptor) {
-    const originalMethod = descriptor.value;
-    const isAsync = originalMethod.constructor.name === 'AsyncFunction';
-    if (isAsync) {
-        descriptor.value = async function (...args) {
-            const className = target.constructor.name;
-            const methodName = `${className}.${propertyKey}`;
-            // Extract meaningful context from arguments
-            const context = extractAPIContext(propertyKey, args);
-            return trace.traceAsync('api', methodName, context, async () => {
-                const startTime = Date.now();
-                try {
-                    // Log API call start
-                    logger.debug(`Linear API Call: ${methodName}`, context);
-                    const result = await originalMethod.apply(this, args);
-                    const duration = Date.now() - startTime;
-                    // Log successful completion with timing
-                    logger.info(`Linear API Success: ${methodName}`, {
-                        duration,
-                        resultType: Array.isArray(result) ? `array[${result.length}]` : typeof result,
-                        hasData: result != null,
-                    });
-                    // Warn about slow API calls
-                    if (duration > 1000) {
-                        logger.warn(`Slow Linear API call: ${methodName} took ${duration}ms`, {
-                            ...context,
-                            duration,
-                        });
-                    }
-                    return result;
-                }
-                catch (error) {
-                    const duration = Date.now() - startTime;
-                    // Enhanced error logging for API failures
-                    logger.error(`Linear API Failed: ${methodName}`, error, {
-                        ...context,
-                        duration,
-                        errorCode: error.code,
-                        statusCode: error.statusCode,
-                        graphQLErrors: error.errors,
-                    });
-                    // Add debugging hints based on error type
-                    if (error.message?.includes('rate limit')) {
-                        logger.warn('Rate limit hit - consider implementing backoff', {
-                            method: methodName,
-                            suggestion: 'Implement exponential backoff or request queuing',
-                        });
-                    }
-                    else if (error.message?.includes('network')) {
-                        logger.warn('Network error - check connectivity', {
-                            method: methodName,
-                            suggestion: 'Verify API endpoint and network connectivity',
-                        });
-                    }
-                    else if (error.message?.includes('unauthorized')) {
-                        logger.warn('Authorization error - check API key', {
-                            method: methodName,
-                            suggestion: 'Verify LINEAR_API_KEY is set and valid',
-                        });
-                    }
-                    throw error;
-                }
-            });
-        };
-    }
-    else {
-        descriptor.value = function (...args) {
-            const className = target.constructor.name;
-            const methodName = `${className}.${propertyKey}`;
-            const context = extractAPIContext(propertyKey, args);
-            return trace.traceSync('api', methodName, context, () => {
-                return originalMethod.apply(this, args);
-            });
-        };
-    }
-    return descriptor;
-}
-/**
- * Extract meaningful context from API method arguments
- */
-function extractAPIContext(methodName, args) {
-    const context = {};
-    // Handle different Linear API methods
-    if (methodName === 'createIssue' && args[0]) {
-        context.title = args[0].title;
-        context.teamId = args[0].teamId;
-        context.priority = args[0].priority;
-    }
-    else if (methodName === 'updateIssue' && args[0]) {
-        context.issueId = args[0];
-        context.updates = Object.keys(args[1] || {});
-    }
-    else if (methodName === 'getIssue') {
-        context.issueId = args[0];
-    }
-    else if (methodName === 'getIssues' && args[0]) {
-        context.filter = args[0];
-    }
-    else if (methodName === 'graphql') {
-        // For raw GraphQL queries
-        const query = args[0];
-        if (query) {
-            // Extract operation name from query
-            const match = query.match(/(?:query|mutation)\s+(\w+)/);
-            context.operation = match ? match[1] : 'unknown';
-            context.queryLength = query.length;
-            context.variables = args[1] ? Object.keys(args[1]) : [];
-        }
-    }
-    return context;
-}
-/**
- * Wrap fetch with tracing for HTTP-level debugging
- */
-export function createTracedFetch(baseFetch = fetch) {
-    return async function tracedFetch(input, init) {
-        const url = typeof input === 'string' ? input : input.toString();
-        const method = init?.method || 'GET';
-        // Mask sensitive headers
-        const headers = init?.headers ? { ...init.headers } : {};
-        if (headers.Authorization) {
-            headers.Authorization = headers.Authorization.substring(0, 20) + '...[MASKED]';
-        }
-        const context = {
-            method,
-            url: url.length > 100 ? url.substring(0, 100) + '...' : url,
-            headers: Object.keys(headers),
-            bodySize: init?.body ? JSON.stringify(init.body).length : 0,
-        };
-        return trace.api(method, url, context, async () => {
-            const startTime = Date.now();
-            try {
-                const response = await baseFetch(input, init);
-                const duration = Date.now() - startTime;
-                // Log response details
-                logger.debug(`HTTP ${method} ${response.status}`, {
-                    url: url.substring(0, 100),
-                    status: response.status,
-                    duration,
-                    headers: {
-                        'content-type': response.headers.get('content-type'),
-                        'x-ratelimit-remaining': response.headers.get('x-ratelimit-remaining'),
-                        'x-ratelimit-reset': response.headers.get('x-ratelimit-reset'),
-                    },
-                });
-                // Warn about rate limiting
-                const remaining = response.headers.get('x-ratelimit-remaining');
-                if (remaining && parseInt(remaining) < 10) {
-                    logger.warn(`Low rate limit remaining: ${remaining}`, {
-                        url: url.substring(0, 100),
-                        resetAt: response.headers.get('x-ratelimit-reset'),
-                    });
-                }
-                // Warn about slow responses
-                if (duration > 2000) {
-                    logger.warn(`Slow HTTP response: ${duration}ms`, {
-                        method,
-                        url: url.substring(0, 100),
-                        status: response.status,
-                    });
-                }
-                return response;
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.error(`HTTP ${method} failed`, error, {
-                    url: url.substring(0, 100),
-                    duration,
-                    errorType: error.constructor.name,
-                    errno: error.errno,
-                    code: error.code,
-                });
-                throw error;
-            }
-        });
-    };
-}
-/**
- * Create a traced GraphQL client wrapper
- */
-export function wrapGraphQLClient(client) {
-    const prototype = Object.getPrototypeOf(client);
-    const propertyNames = Object.getOwnPropertyNames(prototype);
-    for (const propertyName of propertyNames) {
-        if (propertyName === 'constructor')
-            continue;
-        const descriptor = Object.getOwnPropertyDescriptor(prototype, propertyName);
-        if (!descriptor || typeof descriptor.value !== 'function')
-            continue;
-        // Apply tracing to all methods
-        TraceLinearAPI(prototype, propertyName, descriptor);
-        Object.defineProperty(prototype, propertyName, descriptor);
-    }
-    return client;
-}