Implementation Best Practices

# Implementation Best Practices## Code Organization### Modular ArchitectureOrganize your INTUE implementation using these modular design principles:1. **Core Module Separation**   - Separate data ingestion, processing, analysis, and execution components   - Define clear interfaces between modules   - Use dependency injection for flexible component substitution2. **Layered Design Pattern**

├── Application Layer (user interfaces, API endpoints) ├── Domain Layer (business logic, agents, strategies) ├── Infrastructure Layer (data access, persistence, external services) └── Core Layer (common utilities, shared models)

3. **Package Structure**

project/ ├── src/ │ ├── agents/ # Trading agents │ ├── protocols/ # Model context protocols │ ├── services/ # Shared services │ ├── data/ # Data management │ ├── execution/ # Trade execution │ ├── risk/ # Risk management │ └── utils/ # Utilities ├── tests/ # Unit and integration tests ├── docs/ # Documentation ├── config/ # Configuration files └── scripts/ # Automation scripts

## Error HandlingImplement comprehensive error handling strategies:1. **Graceful Degradation**- Design systems to continue functioning with reduced capabilities when errors occur- Implement fallback mechanisms for critical components- Prioritize core functionality during partial system failures2. **Error Categorization**```javascript// Error typesclass DataSourceError extends Error {  constructor(message, source, details) {    super(message);    this.name = 'DataSourceError';    this.source = source;    this.details = details;    this.recoverable = true;  }}class StrategyExecutionError extends Error {  constructor(message, strategy, parameters, details) {    super(message);    this.name = 'StrategyExecutionError';    this.strategy = strategy;    this.parameters = parameters;    this.details = details;    this.recoverable = false;  }}// Error handlingtry {  const result = await executeStrategy(strategy, parameters);  return result;} catch (error) {  if (error instanceof DataSourceError && error.recoverable) {    logger.warn(`Recoverable data source error: ${error.message}`, {      source: error.source,      details: error.details    });        return await useFallbackDataSource(error.source);  } else if (error instanceof StrategyExecutionError) {    logger.error(`Strategy execution failed: ${error.message}`, {      strategy: error.strategy,      parameters: error.parameters    });        alertSystem.notify('strategy_failure', error);    return null;  } else {    logger.error(`Unexpected error: ${error.message}`, {      stack: error.stack    });        throw error; // Re-throw unexpected errors  }}

Retry Mechanisms

javascriptasync function executeWithRetry(fn, options = {}) {  const {    maxRetries = 3,    baseDelayMs = 500,    exponentialBackoff = true,    retryableErrors = [DataSourceError, NetworkError]  } = options;    let lastError;    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {    try {      return await fn();    } catch (error) {      const isRetryable = retryableErrors.some(errorType =>         error instanceof errorType      );            if (!isRetryable || attempt > maxRetries) {        throw error;      }            lastError = error;            // Calculate delay with exponential backoff      const delay = exponentialBackoff        ? baseDelayMs * Math.pow(2, attempt - 1)        : baseDelayMs;            logger.warn(`Retry attempt ${attempt}/${maxRetries} after ${delay}ms`, {        error: error.message      });            await new Promise(resolve => setTimeout(resolve, delay));    }  }    throw lastError;}

Testing Strategies

Implement comprehensive testing for reliable systems:

Unit Testing

javascript// Agent unit test exampledescribe('MomentumAgent', () => {  let agent;  let mockDataProvider;    beforeEach(() => {    mockDataProvider = {      getMarketData: jest.fn()    };        agent = new MomentumAgent({      dataProvider: mockDataProvider    });  });    test('should generate buy signal on positive momentum', async () => {    // Arrange    mockDataProvider.getMarketData.mockResolvedValue({      prices: [100, 101, 103, 106, 110],      volumes: [1000, 1100, 1200, 1300, 1500]    });        // Act    const signals = await agent.generateSignals({      asset: 'BTC',      timeframe: '1h'    });        // Assert    expect(signals).toHaveLength(1);    expect(signals[0].direction).toBe('buy');    expect(signals[0].confidence).toBeGreaterThan(0.7);  });    test('should generate sell signal on negative momentum', async () => {    // Arrange    mockDataProvider.getMarketData.mockResolvedValue({      prices: [110, 108, 105, 103, 100],      volumes: [1500, 1400, 1300, 1200, 1100]    });        // Act    const signals = await agent.generateSignals({      asset: 'BTC',      timeframe: '1h'    });        // Assert    expect(signals).toHaveLength(1);    expect(signals[0].direction).toBe('sell');    expect(signals[0].confidence).toBeGreaterThan(0.7);  });    test('should not generate signal with insufficient data', async () => {    // Arrange    mockDataProvider.getMarketData.mockResolvedValue({      prices: [105, 106],      volumes: [1000, 1050]    });        // Act    const signals = await agent.generateSignals({      asset: 'BTC',      timeframe: '1h'    });        // Assert    expect(signals).toHaveLength(0);  });});

Integration Testing

javascriptdescribe('Signal Processing Pipeline', () => {  let pipeline;  let dataSource;  let signalProcessor;  let riskManager;    beforeEach(async () => {    // Set up test database    dataSource = new MarketDataSource({      connectionString: process.env.TEST_DB_CONNECTION    });        // Initialize components    signalProcessor = new SignalProcessor();    riskManager = new RiskManager();        // Create processing pipeline    pipeline = new SignalPipeline({      dataSource,      signalProcessor,      riskManager    });        // Seed test data    await seedTestMarketData(dataSource);  });    afterEach(async () => {    // Clean up test data    await cleanupTestMarketData(dataSource);  });    test('should process signals through entire pipeline', async () => {    // Arrange    const testParameters = {      assets: ['BTC', 'ETH'],      timeframe: '1h',      startTime: new Date('2023-06-01T00:00:00Z'),      endTime: new Date('2023-06-02T00:00:00Z')    };        // Act    const result = await pipeline.process(testParameters);        // Assert    expect(result.processedSignals).toBeDefined();    expect(result.riskAdjustedSignals).toBeDefined();    expect(result.executionPlan).toBeDefined();        // Verify signal transformation    expect(result.processedSignals.length).toBeGreaterThan(0);    expect(result.riskAdjustedSignals.length).toBeLessThanOrEqual(      result.processedSignals.length    );  });    test('should handle missing market data gracefully', async () => {    // Arrange    const testParameters = {      assets: ['UNKNOWN_ASSET'],      timeframe: '1h',      startTime: new Date('2023-06-01T00:00:00Z'),      endTime: new Date('2023-06-02T00:00:00Z')    };        // Act & Assert    await expect(pipeline.process(testParameters))      .resolves.toEqual({        processedSignals: [],        riskAdjustedSignals: [],        executionPlan: { trades: [] },        errors: expect.any(Array)      });  });});

Scenario Testing

javascriptdescribe('Market Crash Scenario', () => {  let tradingSystem;    beforeEach(async () => {    // Initialize trading system with test configuration    tradingSystem = await initializeTestTradingSystem();        // Set up mock exchange    const mockExchange = new MockExchange();    tradingSystem.setExchangeAdapter(mockExchange);  });    test('should implement circuit breakers during market crash', async () => {    // Arrange - set up market crash scenario    const crashScenario = generateMarketCrashScenario({      initialDrop: 0.15, // 15% initial drop      duration: '4h',      volatility: 'high'    });        // Act - feed crash data to the system    const systemResponse = await simulateScenario(      tradingSystem,      crashScenario    );        // Assert - verify risk management responses    expect(systemResponse.circuitBreakerActivated).toBe(true);    expect(systemResponse.positionSizeReduction).toBeGreaterThan(0.5);    expect(systemResponse.executedTrades.length).toBeLessThanOrEqual(1);        // Verify portfolio protection measures    expect(systemResponse.portfolioValue.finalDrawdown).toBeLessThan(0.2);    expect(systemResponse.protectiveActions).toContain('increased_cash_position');  });    test('should recover trading after market stabilization', async () => {    // Arrange - set up crash and recovery scenario    const fullScenario = generateMarketCrashAndRecoveryScenario({      crashDuration: '4h',      stabilizationDuration: '12h',      recoveryDuration: '24h'    });        // Act - feed scenario data to the system    const systemResponse = await simulateScenario(      tradingSystem,      fullScenario    );        // Assert - verify recovery behavior    expect(systemResponse.tradingResumed).toBe(true);    expect(systemResponse.timeToRecovery).toBeLessThan(24 * 60 * 60 * 1000);    expect(systemResponse.positionSizeProgression).toMatchPattern('increasing');  });});

Performance Monitoring

Implement comprehensive monitoring systems:

Key Metrics Tracking

javascriptclass PerformanceMonitor {  constructor() {    this.metrics = {      executionTimes: new ExponentialMovingAverage(100),      memoryUsage: new TimeSeriesStore(1000),      errorRates: new SlidingWindowCounter(60 * 60 * 1000), // 1 hour window      throughput: new ThroughputCalculator()    };        this.startMonitoring();  }    trackExecutionTime(operation, timeMs) {    this.metrics.executionTimes.record(operation, timeMs);    this.metrics.throughput.recordOperation(operation);  }    trackError(operation, error) {    this.metrics.errorRates.increment(`${operation}_${error.name}`);  }    getPerformanceReport() {    return {      executionTimes: {        mean: this.metrics.executionTimes.getMean(),        p95: this.metrics.executionTimes.getPercentile(95),        p99: this.metrics.executionTimes.getPercentile(99)      },      memoryUsage: {        current: process.memoryUsage().heapUsed,        trend: this.metrics.memoryUsage.getTrend(),        peak: this.metrics.memoryUsage.getMax()      },      errorRates: {        overall: this.metrics.errorRates.getTotal(),        byType: this.metrics.errorRates.getBreakdown()      },      throughput: {        operationsPerSecond: this.metrics.throughput.getOperationsPerSecond(),        byOperation: this.metrics.throughput.getBreakdown()      },      timestamp: Date.now()    };  }    startMonitoring() {    // Record memory usage every 5 seconds    setInterval(() => {      const memoryUsage = process.memoryUsage();      this.metrics.memoryUsage.record({        heapUsed: memoryUsage.heapUsed,        heapTotal: memoryUsage.heapTotal,        rss: memoryUsage.rss      });    }, 5000);        // Log performance report every minute    setInterval(() => {      const report = this.getPerformanceReport();      logger.info('Performance metrics', report);            // Check for anomalies      this.checkForAnomalies(report);    }, 60000);  }    checkForAnomalies(report) {    // Check execution time anomalies    if (report.executionTimes.p95 > 1000) { // Over 1 second      logger.warn('Execution time anomaly detected', {        p95: report.executionTimes.p95      });    }        // Check error rate anomalies    if (report.errorRates.overall > 10) { // More than 10 errors per hour      logger.warn('Error rate anomaly detected', {        errorRate: report.errorRates.overall      });    }        // Check memory usage anomalies    if (report.memoryUsage.trend === 'increasing_rapidly') {      logger.warn('Memory usage anomaly detected', {        currentUsage: report.memoryUsage.current,        trend: report.memoryUsage.trend      });    }  }}// Usage exampleconst monitor = new PerformanceMonitor();async function monitoredOperation() {  const startTime = performance.now();    try {    const result = await performOperation();        // Record execution time    monitor.trackExecutionTime(      'performOperation',      performance.now() - startTime    );        return result;  } catch (error) {    // Record error    monitor.trackError('performOperation', error);    throw error;  }}

Alerting System

javascriptclass AlertSystem {  constructor(config) {    this.config = config;    this.alertProviders = this._initializeProviders(config.providers);    this.alertThresholds = config.thresholds || {};    this.alertHistory = [];    this.minAlertInterval = config.minAlertInterval || 10 * 60 * 1000; // 10 minutes    this.lastAlerts = new Map();  }    _initializeProviders(providerConfigs) {    const providers = {};        for (const [name, config] of Object.entries(providerConfigs)) {      switch (name) {        case 'email':          providers.email = new EmailAlertProvider(config);          break;        case 'slack':          providers.slack = new SlackAlertProvider(config);          break;        case 'sms':          providers.sms = new SMSAlertProvider(config);          break;        case 'pagerduty':          providers.pagerduty = new PagerDutyAlertProvider(config);          break;      }    }        return providers;  }    async sendAlert(alertType, data, options = {}) {    // Check if we should throttle this alert    if (this._shouldThrottleAlert(alertType, options.throttleKey)) {      logger.debug(`Alert throttled: ${alertType}`);      return false;    }        // Determine severity    const severity = options.severity ||       this._determineSeverity(alertType, data);        // Create alert object    const alert = {      type: alertType,      severity,      data,      timestamp: Date.now(),      message: options.message || this._generateAlertMessage(alertType, data)    };        // Determine which providers to use based on severity    const targetsForSeverity = this.config.routingBySeverity?.[severity] ||       Object.keys(this.alertProviders);        // Send to all appropriate providers    const results = [];        for (const target of targetsForSeverity) {      if (this.alertProviders[target]) {        try {          const result = await this.alertProviders[target].sendAlert(alert);          results.push({ provider: target, success: true, result });        } catch (error) {          logger.error(`Failed to send alert via ${target}`, error);          results.push({ provider: target, success: false, error });        }      }    }        // Record alert in history    this.alertHistory.push({      ...alert,      results    });        // Trim history if needed    if (this.alertHistory.length > 1000) {      this.alertHistory = this.alertHistory.slice(-1000);    }        // Update throttle timestamps    this.lastAlerts.set(      this._getThrottleKey(alertType, options.throttleKey),      Date.now()    );        return {      sent: results.some(r => r.success),      results    };  }    _shouldThrottleAlert(alertType, throttleKey) {    const key = this._getThrottleKey(alertType, throttleKey);    const lastSent = this.lastAlerts.get(key);        if (!lastSent) {      return false;    }        const elapsed = Date.now() - lastSent;    return elapsed < this.minAlertInterval;  }    _getThrottleKey(alertType, customKey) {    return customKey ? `${alertType}_${customKey}` : alertType;  }    _determineSeverity(alertType, data) {    const thresholds = this.alertThresholds[alertType];        if (!thresholds) {      return 'info';    }        // Find the matching severity based on thresholds    for (const [severity, threshold] of Object.entries(thresholds)) {      const match = Object.entries(threshold).every(([key, value]) => {        const dataValue = data[key];                if (typeof value === 'object') {          if (value.min !== undefined && dataValue < value.min) {            return false;          }          if (value.max !== undefined && dataValue > value.max) {            return false;          }          return true;        }                return dataValue === value;      });            if (match) {        return severity;      }    }        return 'info';  }    _generateAlertMessage(alertType, data) {    // Generate default message based on alert type    switch (alertType) {      case 'high_error_rate':        return `Error rate threshold exceeded: ${data.errorRate} errors/minute`;      case 'memory_usage':        return `High memory usage detected: ${Math.round(data.memoryUsage / 1024 / 1024)}MB`;      case 'api_latency':        return `API latency threshold exceeded: ${data.latency}ms`;      case 'trade_execution_failure':        return `Trade execution failed for ${data.asset}: ${data.reason}`;      default:        return `Alert: ${alertType}`;    }  }    getRecentAlerts(options = {}) {    const {       limit = 50,      types,      minSeverity,      startTime    } = options;        let filtered = [...this.alertHistory];        // Filter by types    if (types) {      filtered = filtered.filter(alert => types.includes(alert.type));    }        // Filter by minimum severity    if (minSeverity) {      const severityLevels = ['info', 'warning', 'error', 'critical'];      const minIndex = severityLevels.indexOf(minSeverity);            filtered = filtered.filter(alert => {        const alertIndex = severityLevels.indexOf(alert.severity);        return alertIndex >= minIndex;      });    }        // Filter by start time    if (startTime) {      filtered = filtered.filter(alert => alert.timestamp >= startTime);    }        // Sort by timestamp (descending) and limit    return filtered      .sort((a, b) => b.timestamp - a.timestamp)      .slice(0, limit);  }}// Usage exampleconst alertSystem = new AlertSystem({  providers: {    email: {      service: 'smtp',      host: 'smtp.example.com',      auth: {        user: 'alerts@example.com',        pass: process.env.SMTP_PASSWORD      },      recipients: ['team@example.com']    },    slack: {      webhookUrl: process.env.SLACK_WEBHOOK_URL,      channel: '#alerts'    }  },  routingBySeverity: {    info: ['slack'],    warning: ['slack'],    error: ['slack', 'email'],    critical: ['slack', 'email', 'sms']  },  thresholds: {    high_error_rate: {      warning: { errorRate: { min: 5 } },      error: { errorRate: { min: 20 } },      critical: { errorRate: { min: 50 } }    },    memory_usage: {      warning: { memoryUsage: { min: 1024 * 1024 * 1024 } }, // 1GB      error: { memoryUsage: { min: 2 * 1024 * 1024 * 1024 } } // 2GB    }  }});// Send alertawait alertSystem.sendAlert('high_error_rate', {  errorRate: 25,  service: 'api-server',  timeWindow: '5min'});

These best practices will help ensure reliable, maintainable, and high-performance INTUE implementations.

PreviousPerformance Optimization NextConclusion

Last updated 3 days ago

# Implementation Best Practices## Code Organization### Modular ArchitectureOrganize your INTUE implementation using these modular design principles:1. **Core Module Separation** - Separate data ingestion, processing, analysis, and execution components - Define clear interfaces between modules - Use dependency injection for flexible component substitution2. **Layered Design Pattern**

## Error HandlingImplement comprehensive error handling strategies:1. **Graceful Degradation**- Design systems to continue functioning with reduced capabilities when errors occur- Implement fallback mechanisms for critical components- Prioritize core functionality during partial system failures2. **Error Categorization**```javascript// Error typesclass DataSourceError extends Error { constructor(message, source, details) { super(message); this.name = 'DataSourceError'; this.source = source; this.details = details; this.recoverable = true; }}class StrategyExecutionError extends Error { constructor(message, strategy, parameters, details) { super(message); this.name = 'StrategyExecutionError'; this.strategy = strategy; this.parameters = parameters; this.details = details; this.recoverable = false; }}// Error handlingtry { const result = await executeStrategy(strategy, parameters); return result;} catch (error) { if (error instanceof DataSourceError && error.recoverable) { logger.warn(`Recoverable data source error: ${error.message}`, { source: error.source, details: error.details }); return await useFallbackDataSource(error.source); } else if (error instanceof StrategyExecutionError) { logger.error(`Strategy execution failed: ${error.message}`, { strategy: error.strategy, parameters: error.parameters }); alertSystem.notify('strategy_failure', error); return null; } else { logger.error(`Unexpected error: ${error.message}`, { stack: error.stack }); throw error; // Re-throw unexpected errors }}

javascriptasync function executeWithRetry(fn, options = {}) { const { maxRetries = 3, baseDelayMs = 500, exponentialBackoff = true, retryableErrors = [DataSourceError, NetworkError] } = options; let lastError; for (let attempt = 1; attempt <= maxRetries + 1; attempt++) { try { return await fn(); } catch (error) { const isRetryable = retryableErrors.some(errorType => error instanceof errorType ); if (!isRetryable || attempt > maxRetries) { throw error; } lastError = error; // Calculate delay with exponential backoff const delay = exponentialBackoff ? baseDelayMs * Math.pow(2, attempt - 1) : baseDelayMs; logger.warn(`Retry attempt ${attempt}/${maxRetries} after ${delay}ms`, { error: error.message }); await new Promise(resolve => setTimeout(resolve, delay)); } } throw lastError;}

javascript// Agent unit test exampledescribe('MomentumAgent', () => { let agent; let mockDataProvider; beforeEach(() => { mockDataProvider = { getMarketData: jest.fn() }; agent = new MomentumAgent({ dataProvider: mockDataProvider }); }); test('should generate buy signal on positive momentum', async () => { // Arrange mockDataProvider.getMarketData.mockResolvedValue({ prices: [100, 101, 103, 106, 110], volumes: [1000, 1100, 1200, 1300, 1500] }); // Act const signals = await agent.generateSignals({ asset: 'BTC', timeframe: '1h' }); // Assert expect(signals).toHaveLength(1); expect(signals[0].direction).toBe('buy'); expect(signals[0].confidence).toBeGreaterThan(0.7); }); test('should generate sell signal on negative momentum', async () => { // Arrange mockDataProvider.getMarketData.mockResolvedValue({ prices: [110, 108, 105, 103, 100], volumes: [1500, 1400, 1300, 1200, 1100] }); // Act const signals = await agent.generateSignals({ asset: 'BTC', timeframe: '1h' }); // Assert expect(signals).toHaveLength(1); expect(signals[0].direction).toBe('sell'); expect(signals[0].confidence).toBeGreaterThan(0.7); }); test('should not generate signal with insufficient data', async () => { // Arrange mockDataProvider.getMarketData.mockResolvedValue({ prices: [105, 106], volumes: [1000, 1050] }); // Act const signals = await agent.generateSignals({ asset: 'BTC', timeframe: '1h' }); // Assert expect(signals).toHaveLength(0); });});

javascriptdescribe('Signal Processing Pipeline', () => { let pipeline; let dataSource; let signalProcessor; let riskManager; beforeEach(async () => { // Set up test database dataSource = new MarketDataSource({ connectionString: process.env.TEST_DB_CONNECTION }); // Initialize components signalProcessor = new SignalProcessor(); riskManager = new RiskManager(); // Create processing pipeline pipeline = new SignalPipeline({ dataSource, signalProcessor, riskManager }); // Seed test data await seedTestMarketData(dataSource); }); afterEach(async () => { // Clean up test data await cleanupTestMarketData(dataSource); }); test('should process signals through entire pipeline', async () => { // Arrange const testParameters = { assets: ['BTC', 'ETH'], timeframe: '1h', startTime: new Date('2023-06-01T00:00:00Z'), endTime: new Date('2023-06-02T00:00:00Z') }; // Act const result = await pipeline.process(testParameters); // Assert expect(result.processedSignals).toBeDefined(); expect(result.riskAdjustedSignals).toBeDefined(); expect(result.executionPlan).toBeDefined(); // Verify signal transformation expect(result.processedSignals.length).toBeGreaterThan(0); expect(result.riskAdjustedSignals.length).toBeLessThanOrEqual( result.processedSignals.length ); }); test('should handle missing market data gracefully', async () => { // Arrange const testParameters = { assets: ['UNKNOWN_ASSET'], timeframe: '1h', startTime: new Date('2023-06-01T00:00:00Z'), endTime: new Date('2023-06-02T00:00:00Z') }; // Act & Assert await expect(pipeline.process(testParameters)) .resolves.toEqual({ processedSignals: [], riskAdjustedSignals: [], executionPlan: { trades: [] }, errors: expect.any(Array) }); });});

javascriptdescribe('Market Crash Scenario', () => { let tradingSystem; beforeEach(async () => { // Initialize trading system with test configuration tradingSystem = await initializeTestTradingSystem(); // Set up mock exchange const mockExchange = new MockExchange(); tradingSystem.setExchangeAdapter(mockExchange); }); test('should implement circuit breakers during market crash', async () => { // Arrange - set up market crash scenario const crashScenario = generateMarketCrashScenario({ initialDrop: 0.15, // 15% initial drop duration: '4h', volatility: 'high' }); // Act - feed crash data to the system const systemResponse = await simulateScenario( tradingSystem, crashScenario ); // Assert - verify risk management responses expect(systemResponse.circuitBreakerActivated).toBe(true); expect(systemResponse.positionSizeReduction).toBeGreaterThan(0.5); expect(systemResponse.executedTrades.length).toBeLessThanOrEqual(1); // Verify portfolio protection measures expect(systemResponse.portfolioValue.finalDrawdown).toBeLessThan(0.2); expect(systemResponse.protectiveActions).toContain('increased_cash_position'); }); test('should recover trading after market stabilization', async () => { // Arrange - set up crash and recovery scenario const fullScenario = generateMarketCrashAndRecoveryScenario({ crashDuration: '4h', stabilizationDuration: '12h', recoveryDuration: '24h' }); // Act - feed scenario data to the system const systemResponse = await simulateScenario( tradingSystem, fullScenario ); // Assert - verify recovery behavior expect(systemResponse.tradingResumed).toBe(true); expect(systemResponse.timeToRecovery).toBeLessThan(24 * 60 * 60 * 1000); expect(systemResponse.positionSizeProgression).toMatchPattern('increasing'); });});

javascriptclass PerformanceMonitor { constructor() { this.metrics = { executionTimes: new ExponentialMovingAverage(100), memoryUsage: new TimeSeriesStore(1000), errorRates: new SlidingWindowCounter(60 * 60 * 1000), // 1 hour window throughput: new ThroughputCalculator() }; this.startMonitoring(); } trackExecutionTime(operation, timeMs) { this.metrics.executionTimes.record(operation, timeMs); this.metrics.throughput.recordOperation(operation); } trackError(operation, error) { this.metrics.errorRates.increment(`${operation}_${error.name}`); } getPerformanceReport() { return { executionTimes: { mean: this.metrics.executionTimes.getMean(), p95: this.metrics.executionTimes.getPercentile(95), p99: this.metrics.executionTimes.getPercentile(99) }, memoryUsage: { current: process.memoryUsage().heapUsed, trend: this.metrics.memoryUsage.getTrend(), peak: this.metrics.memoryUsage.getMax() }, errorRates: { overall: this.metrics.errorRates.getTotal(), byType: this.metrics.errorRates.getBreakdown() }, throughput: { operationsPerSecond: this.metrics.throughput.getOperationsPerSecond(), byOperation: this.metrics.throughput.getBreakdown() }, timestamp: Date.now() }; } startMonitoring() { // Record memory usage every 5 seconds setInterval(() => { const memoryUsage = process.memoryUsage(); this.metrics.memoryUsage.record({ heapUsed: memoryUsage.heapUsed, heapTotal: memoryUsage.heapTotal, rss: memoryUsage.rss }); }, 5000); // Log performance report every minute setInterval(() => { const report = this.getPerformanceReport(); logger.info('Performance metrics', report); // Check for anomalies this.checkForAnomalies(report); }, 60000); } checkForAnomalies(report) { // Check execution time anomalies if (report.executionTimes.p95 > 1000) { // Over 1 second logger.warn('Execution time anomaly detected', { p95: report.executionTimes.p95 }); } // Check error rate anomalies if (report.errorRates.overall > 10) { // More than 10 errors per hour logger.warn('Error rate anomaly detected', { errorRate: report.errorRates.overall }); } // Check memory usage anomalies if (report.memoryUsage.trend === 'increasing_rapidly') { logger.warn('Memory usage anomaly detected', { currentUsage: report.memoryUsage.current, trend: report.memoryUsage.trend }); } }}// Usage exampleconst monitor = new PerformanceMonitor();async function monitoredOperation() { const startTime = performance.now(); try { const result = await performOperation(); // Record execution time monitor.trackExecutionTime( 'performOperation', performance.now() - startTime ); return result; } catch (error) { // Record error monitor.trackError('performOperation', error); throw error; }}

javascriptclass AlertSystem { constructor(config) { this.config = config; this.alertProviders = this._initializeProviders(config.providers); this.alertThresholds = config.thresholds || {}; this.alertHistory = []; this.minAlertInterval = config.minAlertInterval || 10 * 60 * 1000; // 10 minutes this.lastAlerts = new Map(); } _initializeProviders(providerConfigs) { const providers = {}; for (const [name, config] of Object.entries(providerConfigs)) { switch (name) { case 'email': providers.email = new EmailAlertProvider(config); break; case 'slack': providers.slack = new SlackAlertProvider(config); break; case 'sms': providers.sms = new SMSAlertProvider(config); break; case 'pagerduty': providers.pagerduty = new PagerDutyAlertProvider(config); break; } } return providers; } async sendAlert(alertType, data, options = {}) { // Check if we should throttle this alert if (this._shouldThrottleAlert(alertType, options.throttleKey)) { logger.debug(`Alert throttled: ${alertType}`); return false; } // Determine severity const severity = options.severity || this._determineSeverity(alertType, data); // Create alert object const alert = { type: alertType, severity, data, timestamp: Date.now(), message: options.message || this._generateAlertMessage(alertType, data) }; // Determine which providers to use based on severity const targetsForSeverity = this.config.routingBySeverity?.[severity] || Object.keys(this.alertProviders); // Send to all appropriate providers const results = []; for (const target of targetsForSeverity) { if (this.alertProviders[target]) { try { const result = await this.alertProviders[target].sendAlert(alert); results.push({ provider: target, success: true, result }); } catch (error) { logger.error(`Failed to send alert via ${target}`, error); results.push({ provider: target, success: false, error }); } } } // Record alert in history this.alertHistory.push({ ...alert, results }); // Trim history if needed if (this.alertHistory.length > 1000) { this.alertHistory = this.alertHistory.slice(-1000); } // Update throttle timestamps this.lastAlerts.set( this._getThrottleKey(alertType, options.throttleKey), Date.now() ); return { sent: results.some(r => r.success), results }; } _shouldThrottleAlert(alertType, throttleKey) { const key = this._getThrottleKey(alertType, throttleKey); const lastSent = this.lastAlerts.get(key); if (!lastSent) { return false; } const elapsed = Date.now() - lastSent; return elapsed < this.minAlertInterval; } _getThrottleKey(alertType, customKey) { return customKey ? `${alertType}_${customKey}` : alertType; } _determineSeverity(alertType, data) { const thresholds = this.alertThresholds[alertType]; if (!thresholds) { return 'info'; } // Find the matching severity based on thresholds for (const [severity, threshold] of Object.entries(thresholds)) { const match = Object.entries(threshold).every(([key, value]) => { const dataValue = data[key]; if (typeof value === 'object') { if (value.min !== undefined && dataValue < value.min) { return false; } if (value.max !== undefined && dataValue > value.max) { return false; } return true; } return dataValue === value; }); if (match) { return severity; } } return 'info'; } _generateAlertMessage(alertType, data) { // Generate default message based on alert type switch (alertType) { case 'high_error_rate': return `Error rate threshold exceeded: ${data.errorRate} errors/minute`; case 'memory_usage': return `High memory usage detected: ${Math.round(data.memoryUsage / 1024 / 1024)}MB`; case 'api_latency': return `API latency threshold exceeded: ${data.latency}ms`; case 'trade_execution_failure': return `Trade execution failed for ${data.asset}: ${data.reason}`; default: return `Alert: ${alertType}`; } } getRecentAlerts(options = {}) { const { limit = 50, types, minSeverity, startTime } = options; let filtered = [...this.alertHistory]; // Filter by types if (types) { filtered = filtered.filter(alert => types.includes(alert.type)); } // Filter by minimum severity if (minSeverity) { const severityLevels = ['info', 'warning', 'error', 'critical']; const minIndex = severityLevels.indexOf(minSeverity); filtered = filtered.filter(alert => { const alertIndex = severityLevels.indexOf(alert.severity); return alertIndex >= minIndex; }); } // Filter by start time if (startTime) { filtered = filtered.filter(alert => alert.timestamp >= startTime); } // Sort by timestamp (descending) and limit return filtered .sort((a, b) => b.timestamp - a.timestamp) .slice(0, limit); }}// Usage exampleconst alertSystem = new AlertSystem({ providers: { email: { service: 'smtp', host: 'smtp.example.com', auth: { user: 'alerts@example.com', pass: process.env.SMTP_PASSWORD }, recipients: ['team@example.com'] }, slack: { webhookUrl: process.env.SLACK_WEBHOOK_URL, channel: '#alerts' } }, routingBySeverity: { info: ['slack'], warning: ['slack'], error: ['slack', 'email'], critical: ['slack', 'email', 'sms'] }, thresholds: { high_error_rate: { warning: { errorRate: { min: 5 } }, error: { errorRate: { min: 20 } }, critical: { errorRate: { min: 50 } } }, memory_usage: { warning: { memoryUsage: { min: 1024 * 1024 * 1024 } }, // 1GB error: { memoryUsage: { min: 2 * 1024 * 1024 * 1024 } } // 2GB } }});// Send alertawait alertSystem.sendAlert('high_error_rate', { errorRate: 25, service: 'api-server', timeWindow: '5min'});