@qiaolei81/copilot-session-viewer 0.3.2 → 0.3.3

package/src/app.js

@@ -9,7 +9,7 @@ const config = require('./config');
 // Middleware
 // Rate limiting disabled for local development
 // const { globalLimiter, insightGenerationLimiter, insightAccessLimiter, uploadLimiter } = require('./middleware/rateLimiting');
-const { requestTimeout, developmentCors, errorHandler, notFoundHandler } = require('./middleware/common');
+const { requestTimeout, developmentCors, errorHandler, notFoundHandler, telemetryLocals } = require('./middleware/common');
 
 // Controllers
 const SessionController = require('./controllers/sessionController');
@@ -68,6 +68,7 @@ function createApp(options = {}) {
   app.use(express.json({ limit: '1mb' }));
   app.use(express.urlencoded({ extended: true }));
   app.use(requestTimeout);
+  app.use(telemetryLocals);
 
   // CORS in development
   if (config.NODE_ENV === 'development') {

package/src/controllers/insightController.js

@@ -1,5 +1,6 @@
 const InsightService = require('../services/insightService');
 const { isValidSessionId } = require('../utils/helpers');
+const { trackEvent, trackMetric, trackException } = require('../telemetry');
 
 class InsightController {
   constructor(insightService = null, sessionService = null) {
@@ -39,10 +40,30 @@ class InsightController {
         return res.status(400).json({ error: 'Session directory not available' });
       }
 
+      const startTime = Date.now();
       const result = await this.insightService.generateInsight(session.id, session.directory, session.source, forceRegenerate);
+      const durationMs = Date.now() - startTime;
+
+      // Track InsightGenerated event
+      trackEvent('InsightGenerated', {
+        sessionId,
+        source: session.source || 'unknown',
+        durationMs: durationMs.toString()
+      });
+
+      // Track InsightGenerationTime metric
+      trackMetric('InsightGenerationTime', durationMs, { sessionId, source: session.source || 'unknown' });
+
       res.json(result);
     } catch (err) {
       console.error('Error generating insight:', err);
+
+      // Track insight generation failure
+      trackException(err, {
+        sessionId: req.params.id,
+        operation: 'generateInsight'
+      });
+
       res.status(500).json({ error: err.message || 'Error generating insight' });
     }
   }
@@ -67,6 +88,12 @@ class InsightController {
       }
 
       const result = await this.insightService.getInsightStatus(session.id, session.directory, session.source);
+
+      // Track InsightViewed event if insight is ready
+      if (result.status === 'ready' && result.report) {
+        trackEvent('InsightViewed', { sessionId });
+      }
+
       res.json(result);
     } catch (err) {
       console.error('Error getting insight status:', err);
@@ -94,6 +121,10 @@ class InsightController {
       }
 
       const result = await this.insightService.deleteInsight(session.id, session.directory, session.source);
+
+      // Track InsightDeleted event
+      trackEvent('InsightDeleted', { sessionId });
+
       res.json(result);
     } catch (err) {
       console.error('Error deleting insight:', err);

package/src/controllers/sessionController.js

@@ -1,5 +1,6 @@
 const SessionService = require('../services/sessionService');
 const { isValidSessionId, buildMetadata } = require('../utils/helpers');
+const { trackEvent, trackMetric } = require('../telemetry');
 const AdmZip = require('adm-zip');
 const path = require('path');
 const fs = require('fs');
@@ -40,6 +41,12 @@ class SessionController {
         sourceHints: JSON.stringify(sourceHints)
       };
 
+      // Track HomepageViewed event
+      trackEvent('HomepageViewed', {
+        sessionCount: paginationData.totalSessions.toString(),
+        sourceFilter: 'copilot'
+      });
+
       res.render('index', templateData);
     } catch (err) {
       console.error('Error loading sessions:', err);
@@ -62,6 +69,29 @@ class SessionController {
       }
 
       const metadata = buildMetadata(session);
+
+      // Track SessionViewed event
+      trackEvent('SessionViewed', {
+        sessionId,
+        source: session.source || 'unknown',
+        eventCount: (session.eventCount || metadata.totalEvents || 0).toString(),
+        duration: (session.duration || metadata.duration || 0).toString(),
+        model: session.model || metadata.model || 'unknown',
+        sessionStatus: session.status || metadata.status || 'unknown'
+      });
+
+      // Track SessionEventCount metric
+      const eventCount = session.eventCount || metadata.totalEvents || 0;
+      if (eventCount > 0) {
+        trackMetric('SessionEventCount', eventCount, { sessionId, source: session.source || 'unknown' });
+      }
+
+      // Track SessionDuration metric
+      const duration = session.duration || metadata.duration || 0;
+      if (duration > 0) {
+        trackMetric('SessionDuration', duration, { sessionId, source: session.source || 'unknown' });
+      }
+
       res.render('session-vue', { sessionId, events: [], metadata });
     } catch (err) {
       console.error('Error loading session:', err);
@@ -84,6 +114,13 @@ class SessionController {
       }
 
       const metadata = buildMetadata(session);
+
+      // Track TimeAnalysisViewed event
+      trackEvent('TimeAnalysisViewed', {
+        sessionId,
+        turnCount: (metadata.totalEvents || 0).toString()
+      });
+
       res.render('time-analyze', { sessionId, events: [], metadata });
     } catch (err) {
       console.error('Error loading time analysis:', err);
@@ -104,6 +141,14 @@ class SessionController {
           return res.status(400).json({ error: 'Invalid pagination parameters' });
         }
         const paginationData = await this.sessionService.getPaginatedSessions(page, limit, sourceFilter);
+
+        // Track SessionListLoaded event for API pagination
+        trackEvent('SessionListLoaded', {
+          page: page.toString(),
+          limit: limit.toString(),
+          totalSessions: paginationData.totalSessions.toString()
+        });
+
         res.set({ 'Cache-Control': 'public, max-age=60' });
         res.json(paginationData);
       } else if (sourceFilter && limit) {
@@ -140,6 +185,13 @@ class SessionController {
       const page = Math.floor(offset / limit) + 1;
       const paginationData = await this.sessionService.getPaginatedSessions(page, limit, sourceFilter);
 
+      // Track SessionListLoaded event
+      trackEvent('SessionListLoaded', {
+        page: page.toString(),
+        limit: limit.toString(),
+        totalSessions: paginationData.totalSessions.toString()
+      });
+
       res.json({
         sessions: paginationData.sessions,
         hasMore: paginationData.hasNextPage,
@@ -382,6 +434,10 @@ class SessionController {
       const zipBuffer = zip.toBuffer();
       res.setHeader('Content-Type', 'application/zip');
       res.setHeader('Content-Disposition', `attachment; filename="session-${sessionId}.zip"`);
+
+      // Track SessionExported event
+      trackEvent('SessionExported', { sessionId });
+
       res.send(zipBuffer);
     } catch (err) {
       console.error('Error exporting session:', err);

package/src/controllers/tagController.js

@@ -1,6 +1,7 @@
 const TagService = require('../services/tagService');
 const SessionRepository = require('../services/sessionRepository');
 const { isValidSessionId } = require('../utils/helpers');
+const { trackEvent } = require('../telemetry');
 
 class TagController {
   constructor(tagService = null, sessionRepository = null) {
@@ -88,6 +89,13 @@ class TagController {
       }
 
       const savedTags = await this.tagService.setSessionTags(session, tags);
+
+      // Track TagUpdated event
+      trackEvent('TagUpdated', {
+        sessionId,
+        tagCount: savedTags.length.toString()
+      });
+
       res.json({ tags: savedTags });
     } catch (err) {
       console.error('Error setting session tags:', err);

package/src/controllers/uploadController.js

@@ -4,6 +4,7 @@ const os = require('os');
 const multer = require('multer');
 const { spawn } = require('child_process');
 const { isValidSessionId } = require('../utils/helpers');
+const { trackEvent, trackException } = require('../telemetry');
 const processManager = require('../utils/processManager');
 const config = require('../config');
 
@@ -72,6 +73,9 @@ class UploadController {
           return res.status(500).json({ error: 'Failed to create zip file' });
         }
 
+        // Track SessionShared event
+        trackEvent('SessionShared', { sessionId });
+
         res.download(zipFile, `session-${sessionId}.zip`, (err) => {
           fs.promises.unlink(zipFile).catch(() => {});
           if (err) {
@@ -181,6 +185,7 @@ class UploadController {
       processManager.register(unzipProcess, { name: 'unzip-import' });
 
       unzipProcess.on('close', async (code) => {
+        let sessionDirName; // Declare here for access in catch block
         try {
           await fs.promises.unlink(zipPath);
 
@@ -195,7 +200,7 @@ class UploadController {
             return res.status(400).json({ error: 'Empty zip file' });
           }
 
-          const sessionDirName = entries[0];
+          sessionDirName = entries[0];
 
           // Validate session directory name to prevent Zip Slip path traversal
           if (!isValidSessionId(sessionDirName)) {
@@ -222,9 +227,23 @@ class UploadController {
           await fs.promises.rename(sessionPath, targetPath);
           await fs.promises.rm(extractDir, { recursive: true, force: true });
 
+          // Track SessionImported event
+          const stats = await fs.promises.stat(zipPath).catch(() => ({ size: 0 }));
+          trackEvent('SessionImported', {
+            format: 'copilot',
+            fileSize: stats.size.toString()
+          });
+
           res.json({ success: true, sessionId: sessionDirName });
         } catch (err) {
           console.error('Error importing session:', err);
+
+          // Track import failure
+          trackException(err, {
+            operation: 'importSession',
+            sessionId: sessionDirName || 'unknown'
+          });
+
           await fs.promises.rm(extractDir, { recursive: true, force: true }).catch(() => {});
           res.status(500).json({ error: 'Error importing session' });
         }
@@ -232,12 +251,24 @@ class UploadController {
 
       unzipProcess.on('error', async (err) => {
         console.error('Error extracting zip:', err);
+
+        // Track upload/extraction failure
+        trackException(err, {
+          operation: 'importSession_unzip'
+        });
+
         await fs.promises.unlink(zipPath).catch(() => {});
         await fs.promises.rm(extractDir, { recursive: true, force: true }).catch(() => {});
         res.status(500).json({ error: 'Failed to extract zip file' });
       });
     } catch (err) {
       console.error('Error processing upload:', err);
+
+      // Track upload processing failure
+      trackException(err, {
+        operation: 'importSession_upload'
+      });
+
       if (req.file) {
         await fs.promises.unlink(req.file.path).catch(() => {});
       }

package/src/middleware/common.js

@@ -1,4 +1,5 @@
 const config = require('../config');
+const { trackException, isEnabled: isTelemetryEnabled } = require('../telemetry');
 
 // Request timeout middleware
 const requestTimeout = (req, res, next) => {
@@ -6,6 +7,15 @@ const requestTimeout = (req, res, next) => {
   next();
 };
 
+// Telemetry middleware - makes telemetry settings available to templates
+const telemetryLocals = (req, res, next) => {
+  res.locals.telemetryEnabled = isTelemetryEnabled;
+  res.locals.telemetryConnectionString = isTelemetryEnabled
+    ? (process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || 'InstrumentationKey=39f4fbf1-d82f-42c3-b4ef-ea92a1fd82cb;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=7d4bb432-f2f5-4526-a5e6-31901e5a2db2')
+    : null;
+  next();
+};
+
 // CORS middleware for development
 const developmentCors = (req, res, next) => {
   if (config.NODE_ENV === 'development') {
@@ -24,6 +34,14 @@ const developmentCors = (req, res, next) => {
 const errorHandler = (err, req, res, _next) => {
   console.error('Unhandled error:', err.stack);
 
+  // Track exception in Application Insights
+  trackException(err, {
+    url: req.url,
+    method: req.method,
+    statusCode: (err.status || 500).toString(),
+    userAgent: (req.headers && req.headers['user-agent']) || 'unknown'
+  });
+
   const statusCode = err.status || 500;
   // Default to production-safe behavior if NODE_ENV is not set
   const isDevelopment = config.NODE_ENV === 'development';
@@ -44,5 +62,6 @@ module.exports = {
   requestTimeout,
   developmentCors,
   errorHandler,
-  notFoundHandler
+  notFoundHandler,
+  telemetryLocals
 };

package/src/telemetry.js

@@ -0,0 +1,152 @@
+/**
+ * Application Insights Telemetry Module
+ *
+ * This module initializes and configures Application Insights for telemetry tracking.
+ * Must be required BEFORE any other modules (especially Express) in server.js.
+ *
+ * Features:
+ * - Auto-collection of requests, dependencies, exceptions, and performance counters
+ * - Custom event and metric tracking
+ * - Automatic disabling in test environments
+ * - Support for manual disabling via DISABLE_TELEMETRY env var
+ */
+
+const appInsights = require('applicationinsights');
+
+// Determine if telemetry should be disabled
+const isTestEnvironment = process.env.NODE_ENV === 'test';
+const isDisabled = process.env.DISABLE_TELEMETRY === 'true' || isTestEnvironment;
+
+// Default connection string (can be overridden via env var)
+const DEFAULT_CONNECTION_STRING = 'InstrumentationKey=39f4fbf1-d82f-42c3-b4ef-ea92a1fd82cb;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=7d4bb432-f2f5-4526-a5e6-31901e5a2db2';
+
+let client = null;
+
+if (!isDisabled) {
+  try {
+    // Get connection string from environment or use default
+    const connectionString = process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || DEFAULT_CONNECTION_STRING;
+
+    // Setup and start Application Insights
+    appInsights.setup(connectionString)
+      .setAutoDependencyCorrelation(true)
+      .setAutoCollectRequests(true)
+      .setAutoCollectPerformance(true, true)
+      .setAutoCollectExceptions(true)
+      .setAutoCollectDependencies(true)
+      .setAutoCollectConsole(false) // Disable console tracking to avoid noise
+      .setUseDiskRetryCaching(true)
+      .setSendLiveMetrics(false) // Disable live metrics for local dev tool
+      .setDistributedTracingMode(appInsights.DistributedTracingModes.AI_AND_W3C)
+      .start();
+
+    client = appInsights.defaultClient;
+
+    // Set context properties
+    client.context.tags[client.context.keys.cloudRole] = 'copilot-session-viewer';
+    client.context.tags[client.context.keys.cloudRoleInstance] = require('os').hostname();
+
+    console.log('✅ Application Insights telemetry initialized');
+  } catch (error) {
+    console.error('❌ Failed to initialize Application Insights:', error.message);
+    // Continue without telemetry rather than crashing
+    client = createNoOpClient();
+  }
+} else {
+  // Return no-op client for test environment or when disabled
+  client = createNoOpClient();
+
+  if (isTestEnvironment) {
+    console.log('📊 Telemetry disabled (test environment)');
+  } else {
+    console.log('📊 Telemetry disabled (DISABLE_TELEMETRY=true)');
+  }
+}
+
+/**
+ * Creates a no-op client that safely ignores all telemetry calls
+ * Used when telemetry is disabled or in test environments
+ */
+function createNoOpClient() {
+  return {
+    trackEvent: () => {},
+    trackMetric: () => {},
+    trackException: () => {},
+    trackTrace: () => {},
+    trackDependency: () => {},
+    trackRequest: () => {},
+    flush: (callback) => {
+      if (callback) callback();
+    }
+  };
+}
+
+/**
+ * Track a custom event
+ * @param {string} name - Event name
+ * @param {Object} properties - Event properties
+ */
+function trackEvent(name, properties = {}) {
+  if (client && client.trackEvent) {
+    client.trackEvent({
+      name,
+      properties
+    });
+  }
+}
+
+/**
+ * Track a custom metric
+ * @param {string} name - Metric name
+ * @param {number} value - Metric value
+ * @param {Object} properties - Additional properties
+ */
+function trackMetric(name, value, properties = {}) {
+  if (client && client.trackMetric) {
+    client.trackMetric({
+      name,
+      value,
+      properties
+    });
+  }
+}
+
+/**
+ * Track an exception
+ * @param {Error} error - Error object
+ * @param {Object} properties - Additional properties
+ */
+function trackException(error, properties = {}) {
+  if (client && client.trackException) {
+    client.trackException({
+      exception: error,
+      properties
+    });
+  }
+}
+
+/**
+ * Flush telemetry data (useful for short-lived processes)
+ * @returns {Promise<void>}
+ */
+function flush() {
+  return new Promise((resolve) => {
+    if (client && client.flush) {
+      client.flush({
+        callback: () => resolve()
+      });
+    } else {
+      resolve();
+    }
+  });
+}
+
+// Export the client and helper functions
+module.exports = {
+  client,
+  trackEvent,
+  trackMetric,
+  trackException,
+  flush,
+  isEnabled: !isDisabled
+};