@jackchuka/gql-ingest 1.0.2 → 1.1.0

package/src/mapper.test.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import { DataMapper } from "./mapper";
 import { GraphQLClientWrapper } from "./graphql-client";
+import { MetricsCollector } from "./metrics";
 
 jest.mock("fs");
 jest.mock("./csv-reader");
@@ -10,6 +11,7 @@ const mockFs = fs as jest.Mocked<typeof fs>;
 
 describe("DataMapper", () => {
   let mockClient: jest.Mocked<GraphQLClientWrapper>;
+  let mockMetrics: jest.Mocked<MetricsCollector>;
   let dataMapper: DataMapper;
   const testBasePath = "/test/base/path";
 
@@ -19,7 +21,15 @@ describe("DataMapper", () => {
       setHeaders: jest.fn(),
     } as any;
 
-    dataMapper = new DataMapper(mockClient, testBasePath);
+    mockMetrics = {
+      startEntityProcessing: jest.fn(),
+      recordSuccess: jest.fn(),
+      recordFailure: jest.fn(),
+      finishEntityProcessing: jest.fn(),
+      getMetrics: jest.fn(),
+    } as any;
+
+    dataMapper = new DataMapper(mockClient, testBasePath, mockMetrics);
   });
 
   afterEach(() => {
@@ -165,7 +175,7 @@ describe("DataMapper", () => {
       await dataMapper.processEntity("configs/test/mappings/users.json");
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        "✗ Failed to create entity for row:",
+        "✗ Failed to create entity for row 1:",
         { user_name: "John" },
         expect.any(Error)
       );
@@ -252,5 +262,74 @@ describe("DataMapper", () => {
         email: "john@example.com",
       });
     });
+
+    it("should call metrics methods during successful processing", async () => {
+      const mockConfig = {
+        csvFile: "data/users.csv",
+        graphqlFile: "graphql/users.graphql",
+        mapping: { name: "user_name" },
+      };
+
+      const mockCsvData = [{ user_name: "John" }, { user_name: "Jane" }];
+      const mockMutation =
+        "mutation CreateUser($name: String!) { createUser(input: { name: $name }) { id } }";
+
+      mockFs.readFileSync
+        .mockReturnValueOnce(JSON.stringify(mockConfig))
+        .mockReturnValueOnce(mockMutation);
+
+      const { readCsvFile } = require("./csv-reader");
+      readCsvFile.mockResolvedValue(mockCsvData);
+
+      mockClient.executeMutation.mockResolvedValue({
+        createUser: { id: "123" },
+      });
+
+      await dataMapper.processEntity("configs/test/mappings/users.json");
+
+      expect(mockMetrics.startEntityProcessing).toHaveBeenCalledWith("users");
+      expect(mockMetrics.recordSuccess).toHaveBeenCalledTimes(2);
+      expect(mockMetrics.recordSuccess).toHaveBeenCalledWith("users");
+      expect(mockMetrics.finishEntityProcessing).toHaveBeenCalledWith("users");
+      expect(mockMetrics.recordFailure).not.toHaveBeenCalled();
+    });
+
+    it("should call metrics methods during failed processing", async () => {
+      const mockConfig = {
+        csvFile: "data/users.csv",
+        graphqlFile: "graphql/users.graphql",
+        mapping: { name: "user_name" },
+      };
+
+      const mockCsvData = [{ user_name: "John" }];
+      const mockMutation =
+        "mutation CreateUser($name: String!) { createUser(input: { name: $name }) { id } }";
+
+      mockFs.readFileSync
+        .mockReturnValueOnce(JSON.stringify(mockConfig))
+        .mockReturnValueOnce(mockMutation);
+
+      const { readCsvFile } = require("./csv-reader");
+      readCsvFile.mockResolvedValue(mockCsvData);
+
+      mockClient.executeMutation.mockRejectedValue(new Error("GraphQL error"));
+
+      const consoleSpy = jest.spyOn(console, "error").mockImplementation();
+
+      await dataMapper.processEntity("configs/test/mappings/users.json");
+
+      expect(mockMetrics.startEntityProcessing).toHaveBeenCalledWith("users");
+      expect(mockMetrics.recordFailure).toHaveBeenCalledTimes(1);
+      expect(mockMetrics.recordFailure).toHaveBeenCalledWith("users");
+      expect(mockMetrics.finishEntityProcessing).toHaveBeenCalledWith("users");
+      expect(mockMetrics.recordSuccess).not.toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+
+    it("should expose metrics through getMetrics method", () => {
+      const metrics = dataMapper.getMetrics();
+      expect(metrics).toBe(mockMetrics);
+    });
   });
 });

package/src/mapper.ts

@@ -1,7 +1,9 @@
-import fs from 'fs';
-import path from 'path';
-import { readCsvFile, CsvRow } from './csv-reader';
-import { GraphQLClientWrapper } from './graphql-client';
+import fs from "fs";
+import path from "path";
+import { readCsvFile, CsvRow } from "./csv-reader";
+import { GraphQLClientWrapper } from "./graphql-client";
+import { MetricsCollector } from "./metrics";
+import { ParallelProcessingConfig } from "./config";
 
 export interface MappingConfig {
   csvFile: string;
@@ -12,69 +14,205 @@ export interface MappingConfig {
 export class DataMapper {
   private client: GraphQLClientWrapper;
   private basePath: string;
+  private metrics: MetricsCollector;
+  private verbose: boolean;
 
-  constructor(client: GraphQLClientWrapper, basePath: string = process.cwd()) {
+  constructor(
+    client: GraphQLClientWrapper,
+    basePath: string = process.cwd(),
+    metrics?: MetricsCollector,
+    verbose: boolean = false
+  ) {
     this.client = client;
     this.basePath = basePath;
+    this.metrics = metrics || new MetricsCollector();
+    this.verbose = verbose;
   }
 
   discoverMappings(configDir: string): string[] {
-    const mappingsPath = path.resolve(this.basePath, configDir, 'mappings');
-    
+    const mappingsPath = path.resolve(this.basePath, configDir, "mappings");
+
     try {
       const files = fs.readdirSync(mappingsPath);
-      const jsonFiles = files
-        .filter(file => file.endsWith('.json'))
-        .sort(); // Alphabetical order for consistent processing
-      
-      console.log(`Discovered ${jsonFiles.length} mapping files: ${jsonFiles.join(', ')}`);
-      return jsonFiles.map(file => path.join(configDir, 'mappings', file));
+      const jsonFiles = files.filter((file) => file.endsWith(".json")).sort(); // Alphabetical order for consistent processing
+
+      console.log(
+        `Discovered ${jsonFiles.length} mapping files: ${jsonFiles.join(", ")}`
+      );
+      return jsonFiles.map((file) => path.join(configDir, "mappings", file));
     } catch (error) {
       console.error(`Error reading mappings directory ${mappingsPath}:`, error);
       return [];
     }
   }
 
-  async processEntity(configPath: string): Promise<void> {
+  async processEntity(
+    configPath: string,
+    parallelConfig?: ParallelProcessingConfig
+  ): Promise<void> {
+    const entityName = path.basename(configPath, ".json");
     console.log(`Processing entity: ${configPath}`);
-    
+
+    this.metrics.startEntityProcessing(entityName);
+
     // Read mapping configuration
     const configFullPath = path.resolve(this.basePath, configPath);
-    const config: MappingConfig = JSON.parse(fs.readFileSync(configFullPath, 'utf8'));
-    
+    const config: MappingConfig = JSON.parse(
+      fs.readFileSync(configFullPath, "utf8")
+    );
+
     // Extract config directory (parent of mappings directory)
     const configDir = path.dirname(path.dirname(configFullPath));
-    
+
     // Read CSV data (relative to config directory)
     const csvPath = path.resolve(configDir, config.csvFile);
     const csvData = await readCsvFile(csvPath);
-    
+
     // Read GraphQL mutation (relative to config directory)
     const graphqlPath = path.resolve(configDir, config.graphqlFile);
-    const mutation = fs.readFileSync(graphqlPath, 'utf8');
+    const mutation = fs.readFileSync(graphqlPath, "utf8");
+
+    // Process rows with optional parallelization
+    if (parallelConfig && parallelConfig.concurrency > 1) {
+      await this.processRowsConcurrently(
+        csvData,
+        mutation,
+        config.mapping,
+        entityName,
+        parallelConfig
+      );
+    } else {
+      await this.processRowsSequentially(
+        csvData,
+        mutation,
+        config.mapping,
+        entityName
+      );
+    }
+
+    this.metrics.finishEntityProcessing(entityName);
+  }
+
+  private async processRowsSequentially(
+    csvData: CsvRow[],
+    mutation: string,
+    mapping: Record<string, string>,
+    entityName: string
+  ): Promise<void> {
+    const totalRows = csvData.length;
     
-    // Process each row
-    for (const row of csvData) {
-      const variables = this.mapCsvRowToVariables(row, config.mapping);
-      
+    for (let i = 0; i < csvData.length; i++) {
+      const row = csvData[i];
+      const variables = this.mapCsvRowToVariables(row, mapping);
+
       try {
-        const result = await this.client.executeMutation(mutation, variables);
-        console.log(`✓ Created entity with result:`, result);
+        await this.client.executeMutation(mutation, variables);
+        this.metrics.recordSuccess(entityName);
+        
+        // Show progress every 10% or at the end (only in non-verbose mode)
+        if (!this.verbose && ((i + 1) % Math.max(1, Math.floor(totalRows / 10)) === 0 || i === totalRows - 1)) {
+          const progress = (((i + 1) / totalRows) * 100).toFixed(1);
+          console.log(`📊 Progress: ${i + 1}/${totalRows} (${progress}%) ✓`);
+        }
       } catch (error) {
-        console.error(`✗ Failed to create entity for row:`, row, error);
+        this.metrics.recordFailure(entityName);
+        if (!this.verbose) {
+          console.error(`✗ Failed to create entity for row ${i + 1}:`, row, error);
+        }
       }
     }
   }
 
-  private mapCsvRowToVariables(row: CsvRow, mapping: Record<string, string>): Record<string, any> {
+  private async processRowsConcurrently(
+    csvData: CsvRow[],
+    mutation: string,
+    mapping: Record<string, string>,
+    entityName: string,
+    parallelConfig: ParallelProcessingConfig
+  ): Promise<void> {
+    const concurrency = parallelConfig.concurrency;
+    console.log(
+      `Processing ${csvData.length} rows with concurrency: ${concurrency}`
+    );
+
+    // Split data into chunks for concurrent processing
+    const chunks = this.chunkArray(csvData, concurrency);
+    let processedCount = 0;
+    const totalRows = csvData.length;
+
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+      const chunk = chunks[chunkIndex];
+      const promises = chunk.map(async (row) => {
+        const variables = this.mapCsvRowToVariables(row, mapping);
+
+        try {
+          const result = await this.client.executeMutation(mutation, variables);
+          this.metrics.recordSuccess(entityName);
+          return { success: true, result, row };
+        } catch (error) {
+          this.metrics.recordFailure(entityName);
+          return { success: false, error, row };
+        }
+      });
+
+      const results = await Promise.allSettled(promises);
+      processedCount += chunk.length;
+
+      // Count successes and failures in this chunk
+      let chunkSuccesses = 0;
+      let chunkFailures = 0;
+      
+      results.forEach((result) => {
+        if (result.status === "fulfilled") {
+          const { success, error, row } = result.value;
+          if (success) {
+            chunkSuccesses++;
+          } else {
+            chunkFailures++;
+            if (!this.verbose) {
+              console.error(`✗ Failed to create entity for row:`, row, error);
+            }
+          }
+        } else {
+          chunkFailures++;
+          if (!this.verbose) {
+            console.error(`✗ Promise rejected:`, result.reason);
+          }
+        }
+      });
+
+      // Show progress update (only in non-verbose mode)
+      if (!this.verbose) {
+        const progress = ((processedCount / totalRows) * 100).toFixed(1);
+        console.log(`📊 Progress: ${processedCount}/${totalRows} (${progress}%) - Chunk ${chunkIndex + 1}: ${chunkSuccesses} ✓, ${chunkFailures} ✗`);
+      }
+    }
+  }
+
+  private chunkArray<T>(array: T[], chunkSize: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+      chunks.push(array.slice(i, i + chunkSize));
+    }
+    return chunks;
+  }
+
+  private mapCsvRowToVariables(
+    row: CsvRow,
+    mapping: Record<string, string>
+  ): Record<string, any> {
     const variables: Record<string, any> = {};
-    
+
     for (const [graphqlVar, csvColumn] of Object.entries(mapping)) {
       if (row[csvColumn] !== undefined) {
         variables[graphqlVar] = row[csvColumn];
       }
     }
-    
+
     return variables;
   }
-}
+
+  getMetrics(): MetricsCollector {
+    return this.metrics;
+  }
+}

package/src/metrics.test.ts

@@ -0,0 +1,207 @@
+import { MetricsCollector } from './metrics';
+
+describe('MetricsCollector', () => {
+  let metrics: MetricsCollector;
+
+  beforeEach(() => {
+    metrics = new MetricsCollector();
+  });
+
+  describe('initialization', () => {
+    it('should initialize with zero counts', () => {
+      expect(metrics.getTotalProcessed()).toBe(0);
+      expect(metrics.getSuccessRate()).toBe(0);
+    });
+
+    it('should have a start time', () => {
+      expect(metrics.getDurationMs()).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('entity processing', () => {
+    it('should start entity processing', () => {
+      metrics.startEntityProcessing('testEntity');
+      const entityMetric = metrics.getEntityMetrics('testEntity');
+      
+      expect(entityMetric).toBeDefined();
+      expect(entityMetric?.entityName).toBe('testEntity');
+      expect(entityMetric?.successCount).toBe(0);
+      expect(entityMetric?.failureCount).toBe(0);
+      expect(entityMetric?.startTime).toBeGreaterThan(0);
+      expect(entityMetric?.endTime).toBeUndefined();
+    });
+
+    it('should not create duplicate entity metrics', () => {
+      metrics.startEntityProcessing('testEntity');
+      metrics.startEntityProcessing('testEntity');
+      
+      const entityMetric = metrics.getEntityMetrics('testEntity');
+      expect(entityMetric).toBeDefined();
+    });
+
+    it('should finish entity processing', () => {
+      metrics.startEntityProcessing('testEntity');
+      metrics.finishEntityProcessing('testEntity');
+      
+      const entityMetric = metrics.getEntityMetrics('testEntity');
+      expect(entityMetric?.endTime).toBeGreaterThan(0);
+    });
+  });
+
+  describe('success and failure recording', () => {
+    beforeEach(() => {
+      metrics.startEntityProcessing('testEntity');
+    });
+
+    it('should record successes', () => {
+      metrics.recordSuccess('testEntity');
+      metrics.recordSuccess('testEntity');
+      
+      const entityMetric = metrics.getEntityMetrics('testEntity');
+      expect(entityMetric?.successCount).toBe(2);
+      expect(entityMetric?.failureCount).toBe(0);
+      expect(metrics.getTotalProcessed()).toBe(2);
+    });
+
+    it('should record failures', () => {
+      metrics.recordFailure('testEntity');
+      metrics.recordFailure('testEntity');
+      
+      const entityMetric = metrics.getEntityMetrics('testEntity');
+      expect(entityMetric?.successCount).toBe(0);
+      expect(entityMetric?.failureCount).toBe(2);
+      expect(metrics.getTotalProcessed()).toBe(2);
+    });
+
+    it('should record mixed results', () => {
+      metrics.recordSuccess('testEntity');
+      metrics.recordFailure('testEntity');
+      metrics.recordSuccess('testEntity');
+      
+      const entityMetric = metrics.getEntityMetrics('testEntity');
+      expect(entityMetric?.successCount).toBe(2);
+      expect(entityMetric?.failureCount).toBe(1);
+      expect(metrics.getTotalProcessed()).toBe(3);
+    });
+
+    it('should handle unknown entity gracefully', () => {
+      expect(() => {
+        metrics.recordSuccess('unknownEntity');
+      }).not.toThrow();
+      
+      expect(metrics.getTotalProcessed()).toBe(0);
+    });
+  });
+
+  describe('multiple entities', () => {
+    beforeEach(() => {
+      metrics.startEntityProcessing('entity1');
+      metrics.startEntityProcessing('entity2');
+    });
+
+    it('should track multiple entities separately', () => {
+      metrics.recordSuccess('entity1');
+      metrics.recordSuccess('entity1');
+      metrics.recordFailure('entity2');
+      
+      const entity1Metrics = metrics.getEntityMetrics('entity1');
+      const entity2Metrics = metrics.getEntityMetrics('entity2');
+      
+      expect(entity1Metrics?.successCount).toBe(2);
+      expect(entity1Metrics?.failureCount).toBe(0);
+      expect(entity2Metrics?.successCount).toBe(0);
+      expect(entity2Metrics?.failureCount).toBe(1);
+      expect(metrics.getTotalProcessed()).toBe(3);
+    });
+  });
+
+  describe('success rate calculation', () => {
+    beforeEach(() => {
+      metrics.startEntityProcessing('testEntity');
+    });
+
+    it('should calculate 100% success rate', () => {
+      metrics.recordSuccess('testEntity');
+      metrics.recordSuccess('testEntity');
+      
+      expect(metrics.getSuccessRate()).toBe(100);
+    });
+
+    it('should calculate 0% success rate', () => {
+      metrics.recordFailure('testEntity');
+      metrics.recordFailure('testEntity');
+      
+      expect(metrics.getSuccessRate()).toBe(0);
+    });
+
+    it('should calculate partial success rate', () => {
+      metrics.recordSuccess('testEntity');
+      metrics.recordFailure('testEntity');
+      metrics.recordFailure('testEntity');
+      
+      expect(metrics.getSuccessRate()).toBeCloseTo(33.3, 1);
+    });
+
+    it('should return 0% for no processed items', () => {
+      expect(metrics.getSuccessRate()).toBe(0);
+    });
+  });
+
+  describe('summary generation', () => {
+    it('should generate summary for empty metrics', () => {
+      const summary = metrics.generateSummary();
+      
+      expect(summary).toContain('Total Processed: 0');
+      expect(summary).toContain('Successes: 0');
+      expect(summary).toContain('Failures: 0');
+      expect(summary).toContain('Success Rate: 0.0%');
+      expect(summary).toContain('Duration:');
+    });
+
+    it('should generate summary with single entity', () => {
+      metrics.startEntityProcessing('testEntity');
+      metrics.recordSuccess('testEntity');
+      metrics.recordFailure('testEntity');
+      metrics.finishEntityProcessing('testEntity');
+      
+      const summary = metrics.generateSummary();
+      
+      expect(summary).toContain('Total Processed: 2');
+      expect(summary).toContain('Successes: 1');
+      expect(summary).toContain('Failures: 1');
+      expect(summary).toContain('Success Rate: 50.0%');
+    });
+
+    it('should generate summary with multiple entities', () => {
+      metrics.startEntityProcessing('entity1');
+      metrics.recordSuccess('entity1');
+      metrics.finishEntityProcessing('entity1');
+      
+      metrics.startEntityProcessing('entity2');
+      metrics.recordFailure('entity2');
+      metrics.finishEntityProcessing('entity2');
+      
+      const summary = metrics.generateSummary();
+      
+      expect(summary).toContain('Total Processed: 2');
+      expect(summary).toContain('Per-Entity Breakdown');
+      expect(summary).toContain('entity1:');
+      expect(summary).toContain('entity2:');
+    });
+  });
+
+  describe('finish processing', () => {
+    it('should set end time and return metrics', () => {
+      metrics.startEntityProcessing('testEntity');
+      metrics.recordSuccess('testEntity');
+      
+      const finalMetrics = metrics.finishProcessing();
+      
+      expect(finalMetrics.endTime).toBeGreaterThan(0);
+      expect(finalMetrics.totalEntities).toBe(1);
+      expect(finalMetrics.totalSuccesses).toBe(1);
+      expect(finalMetrics.totalFailures).toBe(0);
+      expect(finalMetrics.entityMetrics.size).toBe(1);
+    });
+  });
+});

package/src/metrics.ts

@@ -0,0 +1,131 @@
+export interface EntityMetrics {
+  entityName: string;
+  successCount: number;
+  failureCount: number;
+  startTime: number;
+  endTime?: number;
+}
+
+export interface ProcessingMetrics {
+  totalEntities: number;
+  totalSuccesses: number;
+  totalFailures: number;
+  entityMetrics: Map<string, EntityMetrics>;
+  requestDurations: number[];
+  startTime: number;
+  endTime?: number;
+}
+
+export class MetricsCollector {
+  private metrics: ProcessingMetrics;
+
+  constructor() {
+    this.metrics = {
+      totalEntities: 0,
+      totalSuccesses: 0,
+      totalFailures: 0,
+      entityMetrics: new Map(),
+      requestDurations: [],
+      startTime: Date.now(),
+    };
+  }
+
+  startEntityProcessing(entityName: string): void {
+    if (!this.metrics.entityMetrics.has(entityName)) {
+      this.metrics.entityMetrics.set(entityName, {
+        entityName,
+        successCount: 0,
+        failureCount: 0,
+        startTime: Date.now(),
+      });
+    }
+  }
+
+  recordSuccess(entityName: string): void {
+    const entityMetric = this.metrics.entityMetrics.get(entityName);
+    if (entityMetric) {
+      entityMetric.successCount++;
+      this.metrics.totalSuccesses++;
+      this.metrics.totalEntities++;
+    }
+  }
+
+  recordFailure(entityName: string): void {
+    const entityMetric = this.metrics.entityMetrics.get(entityName);
+    if (entityMetric) {
+      entityMetric.failureCount++;
+      this.metrics.totalFailures++;
+      this.metrics.totalEntities++;
+    }
+  }
+
+  finishEntityProcessing(entityName: string): void {
+    const entityMetric = this.metrics.entityMetrics.get(entityName);
+    if (entityMetric) {
+      entityMetric.endTime = Date.now();
+    }
+  }
+
+  finishProcessing(): ProcessingMetrics {
+    this.metrics.endTime = Date.now();
+    return { ...this.metrics };
+  }
+
+  getEntityMetrics(entityName: string): EntityMetrics | undefined {
+    return this.metrics.entityMetrics.get(entityName);
+  }
+
+  getTotalProcessed(): number {
+    return this.metrics.totalEntities;
+  }
+
+  getSuccessRate(): number {
+    if (this.metrics.totalEntities === 0) return 0;
+    return (this.metrics.totalSuccesses / this.metrics.totalEntities) * 100;
+  }
+
+  recordRequestDuration(duration: number): void {
+    this.metrics.requestDurations.push(duration);
+  }
+
+  getAverageRequestDuration(): number {
+    if (this.metrics.requestDurations.length === 0) return 0;
+    const sum = this.metrics.requestDurations.reduce((a, b) => a + b, 0);
+    return sum / this.metrics.requestDurations.length;
+  }
+
+  getDurationMs(): number {
+    const endTime = this.metrics.endTime || Date.now();
+    return endTime - this.metrics.startTime;
+  }
+
+  generateSummary(): string {
+    const duration = this.getDurationMs();
+    const successRate = this.getSuccessRate();
+    const avgRequestDuration = this.getAverageRequestDuration();
+    
+    let summary = `\n📊 Processing Summary:\n`;
+    summary += `   Total Processed: ${this.metrics.totalEntities}\n`;
+    summary += `   ✓ Successes: ${this.metrics.totalSuccesses}\n`;
+    summary += `   ✗ Failures: ${this.metrics.totalFailures}\n`;
+    summary += `   Success Rate: ${successRate.toFixed(1)}%\n`;
+    summary += `   Duration: ${(duration / 1000).toFixed(2)}s\n`;
+    
+    if (this.metrics.requestDurations.length > 0) {
+      summary += `   Avg Request Time: ${avgRequestDuration.toFixed(0)}ms\n`;
+    }
+
+    if (this.metrics.entityMetrics.size > 1) {
+      summary += `\n📋 Per-Entity Breakdown:\n`;
+      for (const [entityName, entityMetric] of this.metrics.entityMetrics) {
+        const entityTotal = entityMetric.successCount + entityMetric.failureCount;
+        const entityRate = entityTotal > 0 ? (entityMetric.successCount / entityTotal) * 100 : 0;
+        const entityDuration = entityMetric.endTime ? entityMetric.endTime - entityMetric.startTime : 0;
+        
+        summary += `   ${entityName}: ${entityTotal} total (${entityMetric.successCount} ✓, ${entityMetric.failureCount} ✗) - ${entityRate.toFixed(1)}% success - ${(entityDuration / 1000).toFixed(2)}s\n`;
+      }
+    }
+
+    return summary;
+  }
+}