Jobverfolgung

Überwachen Sie den Fortschritt von Jobs

Verfolgen Sie den Ausführungsstatus von Jobs, überwachen Sie den Fortschritt und rufen Sie detaillierte Ausführungsprotokolle ab.

Job-Ausführungsprotokolle abrufen

GET /api/{tenantId}/{projectId}/execution/job/{jobId}/logs

Ruft detaillierte Ausführungsprotokolle für einen bestimmten Job ab, einschließlich Fortschrittsaktualisierungen, Fehlermeldungen und Leistungskennzahlen.

Parameter

Parameter	Typ	Ort	Beschreibung
tenantId	GUID	Pfad	Die Mandantenkennung
projectId	GUID	Pfad	Die Projektkennung
jobId	GUID	Pfad	Die Jobkennung

Abfrageparameter

Parameter	Typ	Beschreibung
level	string	Filter nach Protokollebene: DEBUG, INFO, WARN, ERROR (Standard: INFO)
fromTime	datetime	Protokolle ab diesem Zeitstempel abrufen
toTime	datetime	Protokolle bis zu diesem Zeitstempel abrufen
limit	integer	Maximale Anzahl der Protokolleinträge (Standard: 1000, max: 10000)
format	string	Antwortformat: structured, raw (Standard: structured)

Antwort

{
  "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
  "jobName": "Customer Journey Analysis",
  "jobStatus": "Running",
  "logsSummary": {
    "totalEntries": 247,
    "debugEntries": 89,
    "infoEntries": 145,
    "warnEntries": 11,
    "errorEntries": 2,
    "timeRange": {
      "startTime": "2024-01-20T10:30:00Z",
      "endTime": "2024-01-20T10:45:00Z"
    }
  },
  "logs": [
    {
      "timestamp": "2024-01-20T10:30:15Z",
      "level": "INFO",
      "component": "DataLoader",
      "stage": "Initialization",
      "message": "Starting data load for dataset 880e8400-e29b-41d4-a716-446655440000",
      "details": {
        "datasetSize": "45.7 MB",
        "expectedRecords": 192850,
        "format": "CSV"
      }
    },
    {
      "timestamp": "2024-01-20T10:32:45Z",
      "level": "INFO",
      "component": "ProcessMiner",
      "stage": "Data Processing",
      "message": "Processing batch 1 of 15",
      "details": {
        "batchSize": 12856,
        "progress": 6.7,
        "recordsPerSecond": 1247
      }
    },
    {
      "timestamp": "2024-01-20T10:38:22Z",
      "level": "WARN",
      "component": "DataValidator",
      "stage": "Data Processing",
      "message": "Found 125 records with missing timestamps",
      "details": {
        "affectedRecords": 125,
        "action": "Timestamp inferred from surrounding events",
        "impactOnAnalysis": "Minimal"
      }
    },
    {
      "timestamp": "2024-01-20T10:41:10Z",
      "level": "ERROR",
      "component": "AnalyticsEngine",
      "stage": "Analysis",
      "message": "Memory limit exceeded during bottleneck analysis",
      "details": {
        "memoryUsage": "3.8 GB",
        "memoryLimit": "4.0 GB",
        "action": "Switching to disk-based processing",
        "retry": true
      }
    },
    {
      "timestamp": "2024-01-20T10:45:33Z",
      "level": "INFO",
      "component": "ReportGenerator",
      "stage": "Output Generation",
      "message": "Generating process map visualization",
      "details": {
        "activitiesCount": 47,
        "pathsCount": 156,
        "formatRequested": "SVG"
      }
    }
  ],
  "executionMetrics": {
    "currentStage": "Output Generation",
    "stageProgress": 78,
    "overallProgress": 85,
    "processingRate": "1250 records/second",
    "memoryUsage": "2.3 GB",
    "cpuUsage": 67,
    "estimatedCompletion": "2024-01-20T10:52:00Z"
  }
}

Job-Fortschritt verfolgen

GET /api/{tenantId}/{projectId}/execution/job/{jobId}/progress

Ruft Echtzeit-Fortschrittsinformationen für einen laufenden Job ab, einschließlich Abschluss je Phase und Leistungsmetriken.

Antwort

{
  "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
  "jobName": "Customer Journey Analysis",
  "status": "Running",
  "overallProgress": {
    "percentage": 85,
    "startTime": "2024-01-20T10:30:00Z",
    "elapsedTime": "15 minutes 33 seconds",
    "estimatedRemaining": "2 minutes 27 seconds",
    "estimatedCompletion": "2024-01-20T10:52:00Z"
  },
  "stages": [
    {
      "stageName": "Data Loading",
      "stageOrder": 1,
      "status": "Completed",
      "progress": 100,
      "startTime": "2024-01-20T10:30:00Z",
      "endTime": "2024-01-20T10:32:15Z",
      "duration": "2 minutes 15 seconds",
      "recordsProcessed": 192850,
      "metrics": {
        "throughput": "1427 records/second",
        "dataValidated": true,
        "errorsFound": 0
      }
    },
    {
      "stageName": "Process Discovery",
      "stageOrder": 2,
      "status": "Completed",
      "progress": 100,
      "startTime": "2024-01-20T10:32:15Z",
      "endTime": "2024-01-20T10:41:30Z",
      "duration": "9 minutes 15 seconds",
      "recordsProcessed": 192850,
      "metrics": {
        "activitiesDiscovered": 47,
        "variantsFound": 234,
        "pathsIdentified": 156
      }
    },
    {
      "stageName": "Performance Analysis",
      "stageOrder": 3,
      "status": "Running",
      "progress": 78,
      "startTime": "2024-01-20T10:41:30Z",
      "estimatedEndTime": "2024-01-20T10:48:00Z",
      "recordsProcessed": 150243,
      "totalRecords": 192850,
      "metrics": {
        "bottlenecksIdentified": 8,
        "waitTimeCalculated": 150243,
        "cycleTimeCalculated": 150243
      }
    },
    {
      "stageName": "Report Generation",
      "stageOrder": 4,
      "status": "Pending",
      "progress": 0,
      "estimatedStartTime": "2024-01-20T10:48:00Z",
      "estimatedEndTime": "2024-01-20T10:52:00Z"
    }
  ],
  "currentActivity": {
    "component": "PerformanceAnalyzer",
    "operation": "Calculating resource utilization metrics",
    "details": "Processing activity transitions for efficiency analysis"
  },
  "resourceUsage": {
    "memoryUsage": "2.3 GB",
    "memoryLimit": "4.0 GB",
    "cpuUsage": 67,
    "diskUsage": "890 MB",
    "networkIO": "12 MB",
    "processingRate": "1250 records/second"
  },
  "qualityMetrics": {
    "dataQualityScore": 94.8,
    "validationsPassed": 15,
    "validationsFailed": 1,
    "warningsGenerated": 11,
    "errorsEncountered": 2
  }
}

Job-Ausführungszeitachse abrufen

GET /api/{tenantId}/{projectId}/execution/job/{jobId}/timeline

Ruft eine detaillierte Zeitachse der Jobausführungsereignisse ab, einschließlich Phasenwechsel, Änderungen der Ressourcenzuweisung und bedeutender Meilensteine.

Abfrageparameter

Parameter	Typ	Beschreibung
includeSubEvents	boolean	Detaillierte Unterereignisse einschließen (Standard: false)
granularity	string	Granularität der Zeitachse: seconds, minutes, major_events (Standard: minutes)

Antwort

{
  "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
  "jobName": "Customer Journey Analysis",
  "timelineScope": {
    "startTime": "2024-01-20T10:30:00Z",
    "currentTime": "2024-01-20T10:45:33Z",
    "endTime": null,
    "granularity": "minutes"
  },
  "timeline": [
    {
      "timestamp": "2024-01-20T10:30:00Z",
      "eventType": "JobStarted",
      "description": "Job execution initiated",
      "details": {
        "submittedBy": "user123",
        "priority": "High",
        "estimatedDuration": "20-25 minutes",
        "resourcesAllocated": {
          "cpuUnits": 2,
          "memoryGB": 4,
          "workerNode": "worker-node-02"
        }
      }
    },
    {
      "timestamp": "2024-01-20T10:30:15Z",
      "eventType": "StageStarted",
      "description": "Data Loading stage initiated",
      "details": {
        "stageName": "Data Loading",
        "expectedDuration": "2-3 minutes",
        "datasetSize": "45.7 MB",
        "recordCount": 192850
      }
    },
    {
      "timestamp": "2024-01-20T10:32:15Z",
      "eventType": "StageCompleted",
      "description": "Data Loading stage completed successfully",
      "details": {
        "stageName": "Data Loading",
        "actualDuration": "2 minutes 15 seconds",
        "recordsLoaded": 192850,
        "dataQualityScore": 98.2,
        "errorsFound": 0
      }
    },
    {
      "timestamp": "2024-01-20T10:32:15Z",
      "eventType": "StageStarted",
      "description": "Process Discovery stage initiated",
      "details": {
        "stageName": "Process Discovery",
        "expectedDuration": "8-12 minutes",
        "algorithm": "Alpha Miner Enhanced"
      }
    },
    {
      "timestamp": "2024-01-20T10:35:30Z",
      "eventType": "Milestone",
      "description": "Process model discovered",
      "details": {
        "activitiesFound": 47,
        "uniqueActivities": 47,
        "processComplexity": "Medium"
      }
    },
    {
      "timestamp": "2024-01-20T10:38:22Z",
      "eventType": "Warning",
      "description": "Data quality issue detected",
      "details": {
        "issue": "Missing timestamps",
        "affectedRecords": 125,
        "resolution": "Timestamps inferred",
        "impact": "Minimal"
      }
    },
    {
      "timestamp": "2024-01-20T10:41:10Z",
      "eventType": "Error",
      "description": "Memory limit approached",
      "details": {
        "memoryUsage": "3.8 GB",
        "memoryLimit": "4.0 GB",
        "action": "Switched to disk-based processing",
        "performanceImpact": "15% slower processing"
      }
    },
    {
      "timestamp": "2024-01-20T10:41:30Z",
      "eventType": "StageCompleted",
      "description": "Process Discovery stage completed",
      "details": {
        "stageName": "Process Discovery",
        "actualDuration": "9 minutes 15 seconds",
        "processVariants": 234,
        "pathsDiscovered": 156
      }
    },
    {
      "timestamp": "2024-01-20T10:41:30Z",
      "eventType": "StageStarted",
      "description": "Performance Analysis stage initiated",
      "details": {
        "stageName": "Performance Analysis",
        "expectedDuration": "6-8 minutes",
        "analysisTypes": ["Bottleneck", "Resource Utilization", "Cycle Time"]
      }
    },
    {
      "timestamp": "2024-01-20T10:45:33Z",
      "eventType": "Progress",
      "description": "Performance Analysis 78% complete",
      "details": {
        "stageName": "Performance Analysis",
        "progress": 78,
        "currentOperation": "Resource utilization analysis",
        "recordsProcessed": 150243,
        "remainingRecords": 42607
      }
    }
  ],
  "upcomingEvents": [
    {
      "estimatedTime": "2024-01-20T10:48:00Z",
      "eventType": "StageCompletion",
      "description": "Performance Analysis stage completion expected"
    },
    {
      "estimatedTime": "2024-01-20T10:48:00Z",
      "eventType": "StageStart",
      "description": "Report Generation stage start expected"
    },
    {
      "estimatedTime": "2024-01-20T10:52:00Z",
      "eventType": "JobCompletion",
      "description": "Job completion expected"
    }
  ]
}

Leistungsmetriken eines Jobs abrufen

GET /api/{tenantId}/{projectId}/execution/job/{jobId}/metrics

Ruft detaillierte Leistungskennzahlen für eine Jobausführung ab, einschließlich Ressourcennutzung, Durchsatz und Effizienzmessungen.

Abfrageparameter

Parameter	Typ	Beschreibung
interval	string	Erfassungsintervall der Metriken: 1m, 5m, 15m (Standard: 5m)
metrics	string	Kommagetrennte Liste von Metriken: cpu, memory, disk, network, throughput
includeHistory	boolean	Historische Metrikdaten einschließen (Standard: false)

Antwort

{
  "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
  "metricsCollectionTime": "2024-01-20T10:45:33Z",
  "currentMetrics": {
    "resourceUtilization": {
      "cpu": {
        "usage": 67,
        "cores": 2,
        "efficiency": 89.2
      },
      "memory": {
        "used": "2.3 GB",
        "allocated": "4.0 GB",
        "peak": "3.8 GB",
        "efficiency": 87.5
      },
      "disk": {
        "reads": "450 MB",
        "writes": "89 MB",
        "iops": 145,
        "latency": "12ms"
      },
      "network": {
        "bytesIn": "67 MB",
        "bytesOut": "12 MB",
        "connections": 8
      }
    },
    "processing": {
      "recordsPerSecond": 1250,
      "recordsProcessed": 150243,
      "totalRecords": 192850,
      "processingEfficiency": 78.3,
      "errorRate": 0.001,
      "retryRate": 0.015
    },
    "stages": {
      "completed": 2,
      "running": 1,
      "pending": 1,
      "averageStageTime": "5.75 minutes",
      "stageEfficiency": 91.2
    }
  },
  "historicalMetrics": [
    {
      "timestamp": "2024-01-20T10:30:00Z",
      "cpu": 15,
      "memory": 0.8,
      "recordsPerSecond": 0,
      "stage": "Initialization"
    },
    {
      "timestamp": "2024-01-20T10:35:00Z",
      "cpu": 85,
      "memory": 1.9,
      "recordsPerSecond": 1427,
      "stage": "Data Loading"
    },
    {
      "timestamp": "2024-01-20T10:40:00Z",
      "cpu": 72,
      "memory": 3.2,
      "recordsPerSecond": 1156,
      "stage": "Process Discovery"
    },
    {
      "timestamp": "2024-01-20T10:45:00Z",
      "cpu": 67,
      "memory": 2.3,
      "recordsPerSecond": 1250,
      "stage": "Performance Analysis"
    }
  ],
  "performanceTrends": {
    "cpuTrend": "Stable",
    "memoryTrend": "Declining",
    "throughputTrend": "Improving",
    "overallEfficiency": "Good",
    "predictionAccuracy": 94.2
  },
  "benchmarks": {
    "jobType": "ProcessMining",
    "averageJobDuration": "18.5 minutes",
    "averageThroughput": "1180 records/second",
    "currentPerformanceRank": "85th percentile",
    "similarJobsComparison": {
      "fasterThan": 85,
      "similarTo": 12,
      "slowerThan": 3
    }
  }
}

Mehrere Jobs verfolgen

GET /api/{tenantId}/{projectId}/execution/tracking/batch

Ruft Verfolgungsinformationen für mehrere Jobs gleichzeitig ab, nützlich für Dashboards und Batch-Überwachung.

Abfrageparameter

Parameter	Typ	Beschreibung
jobIds	string	Kommagetrennte Liste von Job-IDs zur Verfolgung
status	string	Filter nach Status: Running, Queued, Completed, Failed
submittedBy	string	Filter nach Benutzer, der die Jobs eingereicht hat
includeMetrics	boolean	Leistungsmetriken für jeden Job einschließen (Standard: false)
refreshInterval	integer	Auto-Aktualisierungsintervall in Sekunden für Echtzeitverfolgung

Antwort

{
  "trackingTime": "2024-01-20T10:45:33Z",
  "jobCount": 5,
  "summary": {
    "running": 3,
    "queued": 1,
    "completed": 1,
    "failed": 0
  },
  "jobs": [
    {
      "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
      "jobName": "Customer Journey Analysis",
      "status": "Running",
      "progress": 85,
      "startTime": "2024-01-20T10:30:00Z",
      "estimatedCompletion": "2024-01-20T10:52:00Z",
      "currentStage": "Performance Analysis",
      "submittedBy": "user123",
      "priority": "High",
      "resourceUsage": {
        "cpu": 67,
        "memory": "2.3 GB",
        "processingRate": "1250 records/second"
      }
    },
    {
      "jobId": "dd0e8400-e29b-41d4-a716-446655440000",
      "jobName": "Sales Data Enrichment",
      "status": "Running",
      "progress": 45,
      "startTime": "2024-01-20T10:35:00Z",
      "estimatedCompletion": "2024-01-20T11:05:00Z",
      "currentStage": "Data Enrichment",
      "submittedBy": "system",
      "priority": "Normal",
      "resourceUsage": {
        "cpu": 52,
        "memory": "1.8 GB",
        "processingRate": "890 records/second"
      }
    },
    {
      "jobId": "ee0e8400-e29b-41d4-a716-446655440000",
      "jobName": "Weekly Report Generation",
      "status": "Queued",
      "progress": 0,
      "queuePosition": 2,
      "estimatedStartTime": "2024-01-20T10:55:00Z",
      "estimatedCompletion": "2024-01-20T11:20:00Z",
      "submittedBy": "user456",
      "priority": "Normal"
    }
  ],
  "systemHealth": {
    "overallLoad": 73,
    "queueHealth": "Good",
    "resourceAvailability": "Medium",
    "estimatedCapacity": "6 additional jobs"
  }
}

Job-Ereignisse abonnieren

POST /api/{tenantId}/{projectId}/execution/job/{jobId}/subscribe

Stellt ein Echtzeit-Abonnement für Job-Ereignisse zur Live-Verfolgung her. Unterstützt WebSocket-Verbindungen und Webhook-Benachrichtigungen.

Anfragetext

{
  "subscriptionType": "webhook",
  "webhookUrl": "https://your-app.com/webhooks/job-events",
  "events": [
    "stageStarted",
    "stageCompleted",
    "progressUpdate",
    "error",
    "warning",
    "jobCompleted"
  ],
  "filters": {
    "minProgressIncrement": 5,
    "includeDebugEvents": false,
    "notifyOnErrors": true
  },
  "authentication": {
    "type": "bearer",
    "token": "your-webhook-auth-token"
  }
}

Antwort

{
  "subscriptionId": "sub-123e8400-e29b-41d4-a716-446655440000",
  "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
  "subscriptionType": "webhook",
  "status": "Active",
  "webhookUrl": "https://your-app.com/webhooks/job-events",
  "eventsSubscribed": [
    "stageStarted",
    "stageCompleted",
    "progressUpdate",
    "error",
    "warning",
    "jobCompleted"
  ],
  "createdAt": "2024-01-20T10:45:33Z",
  "expiresAt": "2024-01-20T18:45:33Z"
}

Job-Abhängigkeiten abrufen

GET /api/{tenantId}/{projectId}/execution/job/{jobId}/dependencies

Ruft Informationen über Job-Abhängigkeiten ab, einschließlich vorausgesetzter Jobs, abhängiger Ressourcen und blockierender Bedingungen.

Antwort

{
  "jobId": "cc0e8400-e29b-41d4-a716-446655440000",
  "dependencies": {
    "prerequisiteJobs": [
      {
        "jobId": "aa0e8400-e29b-41d4-a716-446655440000",
        "jobName": "Data Preparation",
        "status": "Completed",
        "completedAt": "2024-01-20T10:25:00Z",
        "dependency": "Dataset must be validated before analysis"
      }
    ],
    "resourceDependencies": [
      {
        "resourceType": "Dataset",
        "resourceId": "880e8400-e29b-41d4-a716-446655440000",
        "resourceName": "Customer Journey Data",
        "status": "Available",
        "lastModified": "2024-01-20T10:25:00Z"
      },
      {
        "resourceType": "ComputeNode",
        "resourceId": "worker-node-02",
        "status": "Allocated",
        "allocatedAt": "2024-01-20T10:30:00Z"
      }
    ],
    "dependentJobs": [
      {
        "jobId": "ee0e8400-e29b-41d4-a716-446655440000",
        "jobName": "Weekly Report Generation",
        "status": "Queued",
        "waitingFor": "Customer Journey Analysis results"
      }
    ]
  },
  "blockingConditions": [
    {
      "condition": "Memory allocation below 2GB",
      "status": "Resolved",
      "resolvedAt": "2024-01-20T10:30:00Z",
      "resolution": "Additional memory allocated"
    }
  ],
  "dependencyGraph": {
    "nodes": [
      {
        "id": "aa0e8400-e29b-41d4-a716-446655440000",
        "type": "PrerequisiteJob",
        "status": "Completed"
      },
      {
        "id": "cc0e8400-e29b-41d4-a716-446655440000",
        "type": "CurrentJob",
        "status": "Running"
      },
      {
        "id": "ee0e8400-e29b-41d4-a716-446655440000",
        "type": "DependentJob",
        "status": "Queued"
      }
    ],
    "edges": [
      {
        "from": "aa0e8400-e29b-41d4-a716-446655440000",
        "to": "cc0e8400-e29b-41d4-a716-446655440000",
        "type": "prerequisite"
      },
      {
        "from": "cc0e8400-e29b-41d4-a716-446655440000",
        "to": "ee0e8400-e29b-41d4-a716-446655440000",
        "type": "dependency"
      }
    ]
  }
}

Beispiel: Vollständiger Job-Verfolgungs-Workflow

Dieses Beispiel zeigt eine umfassende Jobverfolgung und -überwachung:

// 1. Start tracking a job
const trackJob = async (jobId) => {
  // Get initial job status
  const progress = await getJobProgress(jobId);
  console.log(`Tracking job: ${progress.jobName}`);
  console.log(`Current progress: ${progress.overallProgress.percentage}%`);

  // Subscribe to real-time events
  await subscribeToJobEvents(jobId);

  return progress;
};

// 2. Get detailed job progress
const getJobProgress = async (jobId) => {
  const response = await fetch(`/api/{tenantId}/{projectId}/execution/job/${jobId}/progress`, {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  return await response.json();
};

// 3. Subscribe to real-time job events
const subscribeToJobEvents = async (jobId) => {
  const response = await fetch(`/api/{tenantId}/{projectId}/execution/job/${jobId}/subscribe`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      subscriptionType: 'webhook',
      webhookUrl: 'https://your-app.com/webhooks/job-events',
      events: [
        'stageStarted',
        'stageCompleted',
        'progressUpdate',
        'error',
        'warning',
        'jobCompleted'
      ],
      filters: {
        minProgressIncrement: 10,
        includeDebugEvents: false,
        notifyOnErrors: true
      }
    })
  });

  const subscription = await response.json();
  console.log(`Subscribed to job events: ${subscription.subscriptionId}`);

  return subscription;
};

// 4. Get job performance metrics
const getJobMetrics = async (jobId) => {
  const response = await fetch(`/api/{tenantId}/{projectId}/execution/job/${jobId}/metrics?interval=5m&includeHistory=true`, {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  const metrics = await response.json();
  console.log('Performance Metrics:');
  console.log(`  CPU Usage: ${metrics.currentMetrics.resourceUtilization.cpu.usage}%`);
  console.log(`  Memory Usage: ${metrics.currentMetrics.resourceUtilization.memory.used}`);
  console.log(`  Processing Rate: ${metrics.currentMetrics.processing.recordsPerSecond} records/sec`);

  return metrics;
};

// 5. Get job execution logs
const getJobLogs = async (jobId, level = 'INFO') => {
  const response = await fetch(`/api/{tenantId}/{projectId}/execution/job/${jobId}/logs?level=${level}&limit=100`, {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  const logs = await response.json();
  console.log(`Retrieved ${logs.logs.length} log entries`);

  // Display recent important logs
  logs.logs.filter(log => log.level !== 'DEBUG').forEach(log => {
    console.log(`[${log.timestamp}] ${log.level}: ${log.message}`);
  });

  return logs;
};

// 6. Track multiple jobs in a dashboard
const trackMultipleJobs = async (jobIds) => {
  const response = await fetch(`/api/{tenantId}/{projectId}/execution/tracking/batch?jobIds=${jobIds.join(',')}&includeMetrics=true`, {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  const tracking = await response.json();
  console.log(`Tracking ${tracking.jobCount} jobs:`);

  tracking.jobs.forEach(job => {
    console.log(`  ${job.jobName}: ${job.status} (${job.progress}%)`);
  });

  return tracking;
};

// 7. Monitor job timeline
const getJobTimeline = async (jobId) => {
  const response = await fetch(`/api/{tenantId}/{projectId}/execution/job/${jobId}/timeline?includeSubEvents=true&granularity=minutes`, {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  const timeline = await response.json();
  console.log('Job Timeline:');

  timeline.timeline.forEach(event => {
    console.log(`[${event.timestamp}] ${event.eventType}: ${event.description}`);
  });

  return timeline;
};

// Execute comprehensive tracking workflow
const runTrackingWorkflow = async (jobId) => {
  try {
    console.log('Starting comprehensive job tracking...');

    // Track job progress
    const progress = await trackJob(jobId);

    // Get performance metrics
    const metrics = await getJobMetrics(jobId);

    // Get execution logs
    const logs = await getJobLogs(jobId, 'WARN');

    // Get timeline
    const timeline = await getJobTimeline(jobId);

    // Monitor until completion
    const monitoring = setInterval(async () => {
      const currentProgress = await getJobProgress(jobId);

      if (currentProgress.status === 'Completed') {
        console.log('Job completed successfully!');
        clearInterval(monitoring);

        // Get final metrics
        const finalMetrics = await getJobMetrics(jobId);
        console.log(`Final efficiency: ${finalMetrics.performanceTrends.overallEfficiency}`);

      } else if (currentProgress.status === 'Failed') {
        console.log('Job failed!');
        clearInterval(monitoring);

        // Get error logs
        const errorLogs = await getJobLogs(jobId, 'ERROR');
        console.log('Error details:', errorLogs.logs);
      } else {
        console.log(`Progress update: ${currentProgress.overallProgress.percentage}%`);
      }
    }, 30000); // Check every 30 seconds

  } catch (error) {
    console.error('Tracking workflow failed:', error);
  }
};

// Start tracking
runTrackingWorkflow('cc0e8400-e29b-41d4-a716-446655440000');

Python-Beispiel

import requests
import time
import json
from datetime import datetime, timedelta

class JobTracker:
    def __init__(self, base_url, tenant_id, project_id, token):
        self.base_url = base_url
        self.tenant_id = tenant_id
        self.project_id = project_id
        self.headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }

    def get_job_progress(self, job_id):
        """Get current job progress"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/job/{job_id}/progress"
        response = requests.get(url, headers=self.headers)
        return response.json()

    def get_job_logs(self, job_id, level='INFO', limit=1000):
        """Get job execution logs"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/job/{job_id}/logs"
        params = {'level': level, 'limit': limit}
        response = requests.get(url, params=params, headers=self.headers)
        return response.json()

    def get_job_metrics(self, job_id, interval='5m', include_history=False):
        """Get job performance metrics"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/job/{job_id}/metrics"
        params = {
            'interval': interval,
            'includeHistory': str(include_history).lower()
        }
        response = requests.get(url, params=params, headers=self.headers)
        return response.json()

    def get_job_timeline(self, job_id, include_sub_events=False, granularity='minutes'):
        """Get job execution timeline"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/job/{job_id}/timeline"
        params = {
            'includeSubEvents': str(include_sub_events).lower(),
            'granularity': granularity
        }
        response = requests.get(url, params=params, headers=self.headers)
        return response.json()

    def track_multiple_jobs(self, job_ids, include_metrics=False):
        """Track multiple jobs simultaneously"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/tracking/batch"
        params = {
            'jobIds': ','.join(job_ids),
            'includeMetrics': str(include_metrics).lower()
        }
        response = requests.get(url, params=params, headers=self.headers)
        return response.json()

    def subscribe_to_job_events(self, job_id, webhook_url, events=None):
        """Subscribe to real-time job events"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/job/{job_id}/subscribe"
        payload = {
            'subscriptionType': 'webhook',
            'webhookUrl': webhook_url,
            'events': events or [
                'stageStarted', 'stageCompleted', 'progressUpdate',
                'error', 'warning', 'jobCompleted'
            ],
            'filters': {
                'minProgressIncrement': 10,
                'includeDebugEvents': False,
                'notifyOnErrors': True
            }
        }
        response = requests.post(url, json=payload, headers=self.headers)
        return response.json()

    def get_job_dependencies(self, job_id):
        """Get job dependencies and blocking conditions"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/execution/job/{job_id}/dependencies"
        response = requests.get(url, headers=self.headers)
        return response.json()

    def monitor_job_until_completion(self, job_id, check_interval=30, timeout=3600):
        """Monitor job until completion with detailed tracking"""
        start_time = time.time()

        print(f"Starting monitoring for job {job_id}")

        # Get initial state
        progress = self.get_job_progress(job_id)
        print(f"Job: {progress['jobName']}")
        print(f"Initial progress: {progress['overallProgress']['percentage']}%")

        while time.time() - start_time < timeout:
            try:
                # Get current progress
                progress = self.get_job_progress(job_id)
                status = progress['status']
                percentage = progress['overallProgress']['percentage']

                print(f"Progress: {percentage}% - Status: {status}")

                if status == 'Completed':
                    print("Job completed successfully!")

                    # Get final metrics
                    metrics = self.get_job_metrics(job_id, include_history=True)
                    print(f"Final efficiency: {metrics['performanceTrends']['overallEfficiency']}")
                    print(f"Total duration: {progress['overallProgress']['elapsedTime']}")

                    return progress

                elif status == 'Failed':
                    print("Job failed!")

                    # Get error logs
                    logs = self.get_job_logs(job_id, level='ERROR')
                    print("Error logs:")
                    for log in logs['logs']:
                        print(f"  [{log['timestamp']}] {log['message']}")

                    return progress

                elif status == 'Running':
                    # Get performance metrics