Made some improvements to the target calc logging....added a comment for later on the highcharts service

Author: MattG57

backend/package.json

@@ -8,7 +8,7 @@
     "start": "node --enable-source-maps dist/index.js | bunyan -o short -l info",
     "test": "vitest",
     "build": "tsc",
-    "dev": "tsx watch src/index.ts | bunyan -o short -l info",
+    "dev": "NODE_OPTIONS='--max-old-space-size=8192' tsx watch src/index.ts | bunyan -o short -l info",
     "lint": "eslint src/**/*.ts",
     "compose:start": "docker-compose -f ../compose.yml up -d",
     "db:start": "docker-compose -f ../compose.yml up -d mongo",

backend/src/controllers/target.controller.ts

@@ -29,14 +29,19 @@ class TargetValuesController {
     try {
       const org = req.query.org || 'enterprise';
       const enableLogging = req.query.enableLogging === 'true';
+      const includeLogsInResponse = req.query.includeLogs === 'true';
 
       // Create an instance of the calculation service
       const calculationService = new TargetCalculationService();
 
-      // Fetch data and calculate targets with optional logging
-      const targets = await calculationService.fetchAndCalculateTargets(org, enableLogging);
+      // Fetch data and calculate targets with optional logging and logs in response
+      const result = await calculationService.fetchAndCalculateTargets(
+        org as string, 
+        enableLogging,
+        includeLogsInResponse
+      );
 
-      return res.status(200).json(targets);
+      return res.status(200).json(result);
     } catch (error) {
       console.error('Error calculating target values:', error);
       return res.status(500).json({ error: 'Failed to calculate target values' });

backend/src/services/target-calculation-service.ts

@@ -63,16 +63,43 @@ export class TargetCalculationService {
   // Flag to enable/disable calculation logging
   debugLogging: boolean = false;
 
+  // Replace individual boolean flags with a Set to track logged calculation names
+  private loggedCalculations: Set<string> = new Set();
+  
   // Tracks calculation readiness
   dataFetched: boolean = false;
 
+  // Collection of logs to return with the response
+  calculationLogs: Array<{
+    name: string;
+    inputs: Record<string, any>;
+    formula: string;
+    result: any;
+  }> = [];
+  
   /**
    * Log calculation details if debug logging is enabled
+   * Each calculation name will only be logged once
    */
   private logCalculation(name: string, inputs: Record<string, any>, formula: string, result: any): void {
-    if (!this.debugLogging) return;
-    
-    console.log(`
+    // Only log if we haven't logged this calculation name before
+    if (!this.loggedCalculations.has(name)) {
+      // Mark this calculation name as logged
+      this.loggedCalculations.add(name);
+      
+      const logEntry = {
+        name,
+        inputs,
+        formula,
+        result
+      };
+      
+      // Store the log entry if debug logging is enabled
+      if (this.debugLogging) {
+        this.calculationLogs.push(logEntry);
+        
+        // Also print to console
+        console.log(`
 ========== CALCULATION: ${name} ==========
 INPUTS:
 ${Object.entries(inputs).map(([key, value]) => `  ${key}: ${JSON.stringify(value)}`).join('\n')}
@@ -84,6 +111,14 @@ RESULT:
   ${JSON.stringify(result)}
 ========================================
 `);
+      }
+    }
+  }
+
+  // Reset the logged calculations set when starting a new calculation run
+  private resetLogging(): void {
+    this.loggedCalculations.clear();
+    this.calculationLogs = [];
   }
 
   /**
@@ -816,32 +851,50 @@ RESULT:
    * One-step method to fetch data and perform all calculations
    * The instance method - used when you already have a service instance
    */
-  async fetchAndCalculateTargets(org: string | null, enableLogging: boolean = false): Promise<Targets> {
+  async fetchAndCalculateTargets(
+    org: string | null, 
+    enableLogging: boolean = false,
+    includeLogsInResponse: boolean = false
+  ): Promise<{ targets: Targets; logs?: Array<any> }> {
     this.debugLogging = enableLogging;
+    this.resetLogging(); // Reset logging state
     console.log(`Calculation logging ${enableLogging ? 'enabled' : 'disabled'}`);
 
-    // Use 'enterprise' as default when org is null or undefined
-   // const orgName = org || 'enterprise';
     await this.fetchCalculationData(org);
-    return this.calculateAllTargets();
+    const targets = this.calculateAllTargets();
+    
+    // Return both targets and logs if requested
+    if (includeLogsInResponse && this.debugLogging) {
+      return { 
+        targets,
+        logs: this.calculationLogs
+      };
+    }
+    
+    return { targets };
   }
 
   /**
    * Static method to create an instance and calculate targets in one step
    * Used for convenience when you don't want to create an instance first
    * This is a facade that creates an instance and calls the instance method
    */
-  static async fetchAndCalculateTargets(org: string | null, enableLogging: boolean = false): Promise<Targets> {
+  static async fetchAndCalculateTargets(
+    org: string | null, 
+    enableLogging: boolean = false,
+    includeLogsInResponse: boolean = false
+  ): Promise<{ targets: Targets; logs?: Array<any> }> {
     const service = new TargetCalculationService();
-    return service.fetchAndCalculateTargets(org, enableLogging);
+    return service.fetchAndCalculateTargets(org, enableLogging, includeLogsInResponse);
   }
 }
 
 // Allow isolated testing
 if (import.meta.url.endsWith(process.argv[1])) {
   (async () => {
-    // Example of using the static method
-    const targets = await TargetCalculationService.fetchAndCalculateTargets('test-org', true);
-    console.log('Calculated Targets:', JSON.stringify(targets, null, 2));
+    // Example of using the static method with logs included in response
+    const result = await TargetCalculationService.fetchAndCalculateTargets('test-org', true, true);
+    console.log('Calculated Targets:', JSON.stringify(result.targets, null, 2));
+    console.log(`Returned ${result.logs?.length || 0} calculation logs`);
   })();
 }

backend/src/services/target.service.ts

@@ -106,7 +106,7 @@ class TargetValuesService {
   }
 
   calculateTargets(settings: SettingsType, adoptions: AdoptionType[]): Promise<Targets> {
-    return TargetCalculationService.fetchAndCalculateTargets(null, true); //always true for now  to audit calculations
+    return TargetCalculationService.fetchAndCalculateTargets(null, false, false); //always true for enableLogging for now  to audit calculations, always false for includeLogsInResponse.
   }
 
   //create default targets if they don't exist  

frontend/src/app/services/highcharts.service.ts

@@ -649,7 +649,7 @@ export class HighchartsService {
 
       if (dateSurveys.length > 0) {
         const avgPercentTimeSaved = dateSurveys.reduce((sum, survey) => sum + survey.percentTimeSaved, 0)
-        acc[dateKey].sum = avgPercentTimeSaved * 0.01 * 0.3 * 40; // TODO pull settings
+        acc[dateKey].sum = avgPercentTimeSaved * 0.01 * 0.3 * 40; // TODO pull settings value, right now fixed at 30% time spent coding
         acc[dateKey].count = dateSurveys.length;
       }