fix(x2a): show correct phase duration and attempt count (#3238)

Use telemetry timestamps for phase duration instead of aggregated
job-level times that include failed pod restarts.

Add attemptCount and firstAttemptAt enrichment fields to the Job schema.

Display attempts and total elapsed time as separate fields in PhaseDetails.

Signed-off-by: Marek Libra <marek.libra@gmail.com>

Author: mareklibra

workspaces/x2a/.changeset/beige-schools-cry.md

@@ -0,0 +1,7 @@
+---
+'@red-hat-developer-hub/backstage-plugin-x2a-backend': patch
+'@red-hat-developer-hub/backstage-plugin-x2a-common': patch
+'@red-hat-developer-hub/backstage-plugin-x2a': patch
+---
+
+Show attempt counter for repeated executions of phases.

workspaces/x2a/plugins/x2a-backend/src/schema/openapi.yaml

@@ -905,6 +905,13 @@ components:
         commitId:
           type: string
           description: Git commit SHA produced by this job
+        attemptCount:
+          type: integer
+          description: Number of restarts (attempts) for this projectId+moduleId+phase combination. Calculated value, not persisted in DB.
+        firstAttemptAt:
+          type: string
+          format: date-time
+          description: When the very first attempt for this phase was started.
 
     ArtifactType:
       type: string

workspaces/x2a/plugins/x2a-backend/src/schema/openapi/generated/models/Job.model.ts

@@ -65,4 +65,12 @@ export interface Job {
    * Git commit SHA produced by this job
    */
   commitId?: string;
+  /**
+   * Number of restarts (attempts) for this projectId+moduleId+phase combination. Calculated value, not persisted in DB.
+   */
+  attemptCount?: number;
+  /**
+   * When the very first attempt for this phase was started.
+   */
+  firstAttemptAt?: Date;
 }

workspaces/x2a/plugins/x2a-backend/src/schema/openapi/generated/router.ts

@@ -1298,6 +1298,15 @@ export const spec = {
           "commitId": {
             "type": "string",
             "description": "Git commit SHA produced by this job"
+          },
+          "attemptCount": {
+            "type": "integer",
+            "description": "Number of restarts (attempts) for this projectId+moduleId+phase combination. Calculated value, not persisted in DB."
+          },
+          "firstAttemptAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "When the very first attempt for this phase was started."
           }
         }
       },

workspaces/x2a/plugins/x2a-backend/src/services/X2ADatabaseService/index.ts

@@ -94,6 +94,18 @@ export class X2ADatabaseService implements X2ADatabaseServiceApi {
     this.#ruleOps = new RuleOperations(logger, dbClient);
   }
 
+  /**
+   * Attaches attemptCount and firstAttemptAt to a Job object (mutates in place).
+   */
+  private attachAttemptStats(
+    job: Job | undefined,
+    stats: { count: number; firstStartedAt: Date | undefined } | undefined,
+  ): void {
+    if (!job || !stats) return;
+    job.attemptCount = stats.count;
+    job.firstAttemptAt = stats.firstStartedAt;
+  }
+
   /**
    * Enriches a project with migration plan and status (used by listProjects and getProject).
    */
@@ -117,6 +129,14 @@ export class X2ADatabaseService implements X2ADatabaseServiceApi {
     );
 
     project.initJob = removeSensitiveFromJob(lastInitJob);
+
+    if (project.initJob) {
+      const stats = await this.#jobOps.getPhaseAttemptStats({
+        projectId,
+        phase: 'init',
+      });
+      this.attachAttemptStats(project.initJob, stats);
+    }
   }
 
   // Projects (facade enriches basic objects when needed)
@@ -348,6 +368,22 @@ export class X2ADatabaseService implements X2ADatabaseServiceApi {
       module.migrate = removeSensitiveFromJob(lastMigrateJobsOfModule[0]);
       module.publish = removeSensitiveFromJob(lastPublishJobsOfModule[0]);
 
+      // Attach attempt stats per phase
+      const phases = ['analyze', 'migrate', 'publish'] as const;
+      await Promise.all(
+        phases.map(async phase => {
+          const job = module[phase];
+          if (job) {
+            const stats = await this.#jobOps.getPhaseAttemptStats({
+              projectId: module.projectId,
+              moduleId: id,
+              phase,
+            });
+            this.attachAttemptStats(job, stats);
+          }
+        }),
+      );
+
       return enrichModuleWithJobStatus(module, {
         analyze: module.analyze,
         migrate: module.migrate,
@@ -401,6 +437,10 @@ export class X2ADatabaseService implements X2ADatabaseServiceApi {
       ),
     );
 
+    const attemptStatsMap = await this.#jobOps.batchPhaseAttemptStats({
+      projectId,
+    });
+
     const response: Array<Module> = modules.map((module, idxModule) => {
       const analyze = removeSensitiveFromJob(
         lastAnalyzeJobsOfModules[idxModule][0],
@@ -411,6 +451,12 @@ export class X2ADatabaseService implements X2ADatabaseServiceApi {
       const publish = removeSensitiveFromJob(
         lastPublishJobsOfModules[idxModule][0],
       );
+
+      const moduleStats = attemptStatsMap.get(module.id);
+      this.attachAttemptStats(analyze, moduleStats?.get('analyze'));
+      this.attachAttemptStats(migrateJob, moduleStats?.get('migrate'));
+      this.attachAttemptStats(publish, moduleStats?.get('publish'));
+
       const lastJobs = { analyze, migrate: migrateJob, publish };
       return enrichModuleWithJobStatus(module, lastJobs);
     });

workspaces/x2a/plugins/x2a-backend/src/services/X2ADatabaseService/jobOperations.ts

@@ -366,6 +366,87 @@ export class JobOperations {
     return this.getJob({ id });
   }
 
+  /**
+   * Returns attempt count and first-attempt timestamp for a single
+   * (projectId, moduleId, phase) combination.
+   */
+  async getPhaseAttemptStats({
+    projectId,
+    moduleId,
+    phase,
+  }: {
+    projectId: string;
+    moduleId?: string | null;
+    phase: MigrationPhase;
+  }): Promise<{ count: number; firstStartedAt: Date | undefined }> {
+    const row = await this.#dbClient('jobs')
+      .where('project_id', projectId)
+      .modify(qb => {
+        if (moduleId) {
+          qb.where('module_id', moduleId);
+        } else if (Phase.from(phase).isProjectPhase()) {
+          qb.whereNull('module_id');
+        }
+      })
+      .where('phase', phase)
+      .select(
+        this.#dbClient.raw('COUNT(*) as count'),
+        this.#dbClient.raw('MIN(started_at) as first_started_at'),
+      )
+      .first();
+
+    const count = Number(row?.count ?? 0);
+    const firstStartedAt = row?.first_started_at
+      ? new Date(row.first_started_at as string | Date)
+      : undefined;
+
+    return { count, firstStartedAt };
+  }
+
+  /**
+   * Batch-fetches attempt stats for every (module_id, phase) pair in a
+   * project. Returns a nested map: moduleId -> phase -> stats.
+   * One SQL query regardless of the number of modules.
+   */
+  async batchPhaseAttemptStats({
+    projectId,
+  }: {
+    projectId: string;
+  }): Promise<
+    Map<
+      string,
+      Map<string, { count: number; firstStartedAt: Date | undefined }>
+    >
+  > {
+    const rows: Array<Record<string, unknown>> = await this.#dbClient('jobs')
+      .where('project_id', projectId)
+      .whereNotNull('module_id')
+      .groupBy('module_id', 'phase')
+      .select(
+        'module_id',
+        'phase',
+        this.#dbClient.raw('COUNT(*) as count'),
+        this.#dbClient.raw('MIN(started_at) as first_started_at'),
+      );
+
+    const result = new Map<
+      string,
+      Map<string, { count: number; firstStartedAt: Date | undefined }>
+    >();
+    for (const row of rows) {
+      const modId = row.module_id as string;
+      const phase = row.phase as string;
+      if (!result.has(modId)) {
+        result.set(modId, new Map());
+      }
+      result.get(modId)!.set(phase, {
+        count: Number(row.count),
+        firstStartedAt: new Date(row.first_started_at as string | Date),
+      });
+    }
+    return result;
+  }
+
   async deleteJob({ id }: { id: string }): Promise<number> {
     this.#logger.info(`deleteJob called for id: ${id}`);
 

workspaces/x2a/plugins/x2a-backend/src/services/X2ADatabaseService/jobs.test.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-import { mockCredentials } from '@backstage/backend-test-utils';
-
 import {
   Artifact,
   toSorted,
 } from '@red-hat-developer-hub/backstage-plugin-x2a-common';
 
+import { mockServices, mockCredentials } from '@backstage/backend-test-utils';
+
 import {
   artifactsFromValues,
   createDatabase,
@@ -32,6 +32,7 @@ import {
   tearDownDatabases,
 } from '../../__testUtils__';
 import { delay } from '../../utils';
+import { JobOperations } from './jobOperations';
 
 describe('X2ADatabaseService – jobs', () => {
   afterEach(async () => {
@@ -773,3 +774,148 @@ describe('X2ADatabaseService – jobs', () => {
     );
   });
 });
+
+describe('JobOperations – phase attempt stats', () => {
+  afterEach(async () => {
+    await tearDownDatabases();
+  });
+
+  describe('getPhaseAttemptStats', () => {
+    it.each(supportedDatabaseIds)(
+      'returns count and firstStartedAt for a single phase - %p',
+      async databaseId => {
+        const { client } = await createDatabase(databaseId);
+        const service = createService(client);
+        const jobOps = new JobOperations(mockServices.logger.mock(), client);
+        const credentials = mockCredentials.user();
+        const project = await service.createProject(
+          {
+            name: 'Test Project',
+            description: 'D',
+            ...defaultProjectRepoFields,
+          },
+          { credentials },
+        );
+        const module = await service.createModule({
+          name: 'Mod',
+          sourcePath: '/mod',
+          projectId: project.id,
+        });
+
+        const firstJob = await service.createJob({
+          projectId: project.id,
+          moduleId: module.id,
+          phase: 'analyze',
+          startedAt: new Date('2024-01-01T10:00:00Z'),
+        });
+        await service.createJob({
+          projectId: project.id,
+          moduleId: module.id,
+          phase: 'analyze',
+          startedAt: new Date('2024-01-01T11:00:00Z'),
+        });
+        await service.createJob({
+          projectId: project.id,
+          moduleId: module.id,
+          phase: 'analyze',
+          startedAt: new Date('2024-01-01T12:00:00Z'),
+        });
+
+        const stats = await jobOps.getPhaseAttemptStats({
+          projectId: project.id,
+          moduleId: module.id,
+          phase: 'analyze',
+        });
+
+        expect(stats.count).toBe(3);
+        expect(stats.firstStartedAt).toBeInstanceOf(Date);
+        expect(stats.firstStartedAt!.toISOString()).toBe(
+          firstJob.startedAt.toISOString(),
+        );
+      },
+      LONG_TEST_TIMEOUT,
+    );
+
+    it.each(supportedDatabaseIds)(
+      'returns count 0 when no jobs exist - %p',
+      async databaseId => {
+        const { client } = await createDatabase(databaseId);
+        const jobOps = new JobOperations(mockServices.logger.mock(), client);
+
+        const stats = await jobOps.getPhaseAttemptStats({
+          projectId: nonExistentId,
+          moduleId: nonExistentId,
+          phase: 'analyze',
+        });
+
+        expect(stats.count).toBe(0);
+        expect(stats.firstStartedAt).toBeUndefined();
+      },
+      LONG_TEST_TIMEOUT,
+    );
+  });
+
+  describe('batchPhaseAttemptStats', () => {
+    it.each(supportedDatabaseIds)(
+      'returns stats grouped by module and phase - %p',
+      async databaseId => {
+        const { client } = await createDatabase(databaseId);
+        const service = createService(client);
+        const jobOps = new JobOperations(mockServices.logger.mock(), client);
+        const credentials = mockCredentials.user();
+        const project = await service.createProject(
+          {
+            name: 'Test Project',
+            description: 'D',
+            ...defaultProjectRepoFields,
+          },
+          { credentials },
+        );
+        const mod1 = await service.createModule({
+          name: 'Mod1',
+          sourcePath: '/mod1',
+          projectId: project.id,
+        });
+        const mod2 = await service.createModule({
+          name: 'Mod2',
+          sourcePath: '/mod2',
+          projectId: project.id,
+        });
+
+        await service.createJob({
+          projectId: project.id,
+          moduleId: mod1.id,
+          phase: 'analyze',
+        });
+        await delay(5);
+        await service.createJob({
+          projectId: project.id,
+          moduleId: mod1.id,
+          phase: 'analyze',
+        });
+        await delay(5);
+        await service.createJob({
+          projectId: project.id,
+          moduleId: mod1.id,
+          phase: 'migrate',
+        });
+        await delay(5);
+        await service.createJob({
+          projectId: project.id,
+          moduleId: mod2.id,
+          phase: 'analyze',
+        });
+
+        const statsMap = await jobOps.batchPhaseAttemptStats({
+          projectId: project.id,
+        });
+
+        expect(statsMap.get(mod1.id)?.get('analyze')?.count).toBe(2);
+        expect(statsMap.get(mod1.id)?.get('migrate')?.count).toBe(1);
+        expect(statsMap.get(mod2.id)?.get('analyze')?.count).toBe(1);
+        expect(statsMap.get(mod2.id)?.get('migrate')).toBeUndefined();
+      },
+      LONG_TEST_TIMEOUT,
+    );
+  });
+});