add-performance-monitoring

Add Performance Monitoring

Setup application performance monitoring

Instructions

1. Performance Monitoring Strategy

   • Define key performance indicators (KPIs) and service level objectives (SLOs)
   • Identify critical user journeys and performance bottlenecks
   • Plan monitoring architecture and data collection strategy
   • Assess existing monitoring infrastructure and integration points
   • Define alerting thresholds and escalation procedures

2. Application Performance Monitoring (APM)

   • Set up comprehensive APM monitoring:

   Node.js APM with New Relic:

   // newrelic.js
   exports.config = {
     app_name: [process.env.NEW_RELIC_APP_NAME || 'My Application'],
     license_key: process.env.NEW_RELIC_LICENSE_KEY,
     distributed_tracing: {
       enabled: true
     },
     transaction_tracer: {
       enabled: true,
       transaction_threshold: 0.5, // 500ms
       record_sql: 'obfuscated',
       explain_threshold: 1000 // 1 second
     },
     error_collector: {
       enabled: true,
       ignore_status_codes: [404, 401]
     },
     browser_monitoring: {
       enable: true
     },
     application_logging: {
       forwarding: {
         enabled: true
       }
     }
   };
   
   // app.js
   require('newrelic');
   const express = require('express');
   const app = express();
   
   // Custom metrics
   const newrelic = require('newrelic');
   
   app.use((req, res, next) => {
     const startTime = Date.now();
     
     res.on('finish', () => {
       const duration = Date.now() - startTime;
       
       // Record custom metrics
       newrelic.recordMetric('Custom/ResponseTime', duration);
       newrelic.recordMetric(`Custom/Endpoint/${req.path}`, duration);
       
       // Add custom attributes
       newrelic.addCustomAttributes({
         'user.id': req.user?.id,
         'request.method': req.method,
         'response.statusCode': res.statusCode
       });
     });
     
     next();
   });
   

   Datadog APM Integration:

   // datadog-tracer.js
   const tracer = require('dd-trace').init({
     service: 'my-application',
     env: process.env.NODE_ENV,
     version: process.env.APP_VERSION,
     logInjection: true,
     runtimeMetrics: true,
     profiling: true,
     analytics: true
   });
   
   // Custom instrumentation
   class PerformanceTracker {
     static startSpan(operationName, options = {}) {
       return tracer.startSpan(operationName, {
         tags: {
           'service.name': 'my-application',
           ...options.tags
         },
         ...options
       });
     }
   
     static async traceAsync(operationName, asyncFn, tags = {}) {
       const span = this.startSpan(operationName, { tags });
       
       try {
         const result = await asyncFn(span);
         span.setTag('operation.success', true);
         return result;
       } catch (error) {
         span.setTag('operation.success', false);
         span.setTag('error.message', error.message);
         span.setTag('error.stack', error.stack);
         throw error;
       } finally {
         span.finish();
       }
     }
   
     static trackDatabaseQuery(query, duration, success) {
       tracer.startSpan('database.query', {
         tags: {
           'db.statement': query,
           'db.duration': duration,
           'db.success': success
         }
       }).finish();
     }
   }
   
   // Usage example
   app.get('/api/users/:id', async (req, res) => {
     await PerformanceTracker.traceAsync('get_user', async (span) => {
       span.setTag('user.id', req.params.id);
       
       const user = await getUserFromDatabase(req.params.id);
       span.setTag('user.found', !!user);
       
       res.json(user);
     }, { endpoint: '/api/users/:id' });
   });