checkup 0.2.6__tar.gz → 0.2.8__tar.gz

{checkup-0.2.6 → checkup-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: checkup
-Version: 0.2.6
+Version: 0.2.8
 Summary: Add your description here
 Author: Jan Vanbuel
 Author-email: Jan Vanbuel <jan.vanbuel@ond.vlaanderen.be>

{checkup-0.2.6 → checkup-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkup"
-version = "0.2.6"
+version = "0.2.8"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Jan Vanbuel", email = "jan.vanbuel@ond.vlaanderen.be" }]

{checkup-0.2.6 → checkup-0.2.8}/src/checkup/executor.py

@@ -54,7 +54,7 @@ class ProviderExecutor:
     """
 
     def execute(
-        self, provider_set: list[Provider], fail_fast: bool = True
+        self, provider_set: list[Provider]
     ) -> tuple[Context, dict[str, Any], list[ProviderError]]:
         """Execute all providers and build namespaced context.
 
@@ -64,14 +64,9 @@ class ProviderExecutor:
 
         Args:
             provider_set: List of provider instances
-            fail_fast: If True, raise on first provider error.
-                       If False, collect errors and continue.
 
         Returns:
             Tuple of (context dict, tags dict, list of errors)
-
-        Raises:
-            ProviderError: If fail_fast=True and a provider fails
         """
         context: Context = {}
         tags: dict[str, Any] = {}
@@ -89,8 +84,6 @@ class ProviderExecutor:
             except Exception as e:
                 error = ProviderError(provider, e)
                 logger.error("Provider %s failed: %s", provider.name, e)
-                if fail_fast:
-                    raise error from e
                 errors.append(error)
 
         return context, tags, errors
@@ -113,6 +106,7 @@ class MetricCalculator:
         context: Context,
         tags: dict[str, Any],
         provided_classes: set[type[Provider]],
+        failed_providers: dict[type[Provider], ProviderError] | None = None,
     ) -> list[Metric]:
         """Calculate all metrics in execution order.
 
@@ -124,13 +118,16 @@ class MetricCalculator:
             context: Context dict from providers
             tags: Tags dict to merge into metrics
             provided_classes: Set of provider classes available
+            failed_providers: Dict mapping failed provider classes to their errors
 
         Returns:
             List of calculated metrics
         """
+        failed_providers = failed_providers or {}
         logger.debug("Starting metric calculation for %d metrics", len(execution_order))
         calculated: dict[type[Metric], Metric] = {}
         skipped: set[type[Metric]] = set()
+        failed: set[type[Metric]] = set()
         result_metrics: list[Metric] = []
 
         i = 0
@@ -138,12 +135,24 @@ class MetricCalculator:
         while i < len(execution_order):
             metric_cls = execution_order[i]
 
-            # Check for skip conditions
+            # Check for skip conditions (missing providers)
             if self._should_skip(metric_cls, provided_classes, skipped):
                 skipped.add(metric_cls)
                 i += 1
                 continue
 
+            # Check for failed provider dependencies
+            failed_deps = self._get_failed_providers(
+                metric_cls, failed_providers, failed
+            )
+            if failed_deps:
+                metric = self._create_failed_metric(metric_cls, tags, failed_deps)
+                calculated[metric_cls] = metric
+                result_metrics.append(metric)
+                failed.add(metric_cls)
+                i += 1
+                continue
+
             # Start a new batch with this executor type
             current_executor = metric_cls.executor
             batch: list[type[Metric]] = [metric_cls]
@@ -160,6 +169,17 @@ class MetricCalculator:
                     i += 1
                     continue
 
+                failed_deps = self._get_failed_providers(
+                    next_cls, failed_providers, failed
+                )
+                if failed_deps:
+                    metric = self._create_failed_metric(next_cls, tags, failed_deps)
+                    calculated[next_cls] = metric
+                    result_metrics.append(metric)
+                    failed.add(next_cls)
+                    i += 1
+                    continue
+
                 if next_cls.executor != current_executor:
                     break  # Different executor, start new batch
 
@@ -192,9 +212,10 @@ class MetricCalculator:
                 )
 
         logger.info(
-            "Metric calculation complete: %d calculated, %d skipped",
-            len(result_metrics),
+            "Metric calculation complete: %d calculated, %d skipped, %d failed",
+            len(result_metrics) - len(failed),
             len(skipped),
+            len(failed),
         )
         return result_metrics
 
@@ -234,6 +255,63 @@ class MetricCalculator:
 
         return False
 
+    def _get_failed_providers(
+        self,
+        metric_cls: type[Metric],
+        failed_providers: dict[type[Provider], ProviderError],
+        failed_metrics: set[type[Metric]],
+    ) -> list[str]:
+        """Get list of failed provider/metric names that this metric depends on.
+
+        Args:
+            metric_cls: Metric class to check
+            failed_providers: Dict of failed provider classes to errors
+            failed_metrics: Set of metrics that failed due to provider errors
+
+        Returns:
+            List of failed provider/metric names, empty if none
+        """
+        failed_names = []
+
+        # Check direct provider dependencies
+        for provider_cls in metric_cls.providers():
+            if provider_cls in failed_providers:
+                failed_names.append(f"provider '{provider_cls.name}'")
+
+        # Check metric dependencies that failed
+        for dep_cls in metric_cls.depends_on():
+            if dep_cls in failed_metrics:
+                failed_names.append(f"metric '{dep_cls.name}'")
+
+        return failed_names
+
+    def _create_failed_metric(
+        self,
+        metric_cls: type[Metric],
+        tags: dict[str, Any],
+        failed_deps: list[str],
+    ) -> Metric:
+        """Create a metric instance with null value due to failed dependencies.
+
+        Args:
+            metric_cls: Metric class to instantiate
+            tags: Tags to merge into the metric
+            failed_deps: List of failed dependency names
+
+        Returns:
+            Metric instance with value=None and diagnostic explaining failure
+        """
+        metric = metric_cls(**self._configs.get(metric_cls.name, {}))
+        metric.tags.update(tags)
+        metric.value = None
+        metric.diagnostic = f"Failed: {', '.join(failed_deps)} failed"
+        logger.debug(
+            "Metric %s marked as failed: %s",
+            metric_cls.name,
+            metric.diagnostic,
+        )
+        return metric
+
     def _execute_batch(
         self,
         batch: list[type[Metric]],

{checkup-0.2.6 → checkup-0.2.8}/src/checkup/hub.py

@@ -73,10 +73,14 @@ def _measure_single_provider_set(
     Raises:
         ProviderError: If a provider fails during execution
     """
-    context, tags, errors = ProviderExecutor().execute(provider_set, fail_fast=True)
-    # errors list will be empty if fail_fast=True since it raises on error
+    context, tags, errors = ProviderExecutor().execute(provider_set)
+    failed_providers = {type(e.provider): e for e in errors}
     return MetricCalculator(metric_configs).calculate(
-        execution_order, context, tags, {type(p) for p in provider_set}
+        execution_order,
+        context,
+        tags,
+        {type(p) for p in provider_set},
+        failed_providers,
     )
 
 
@@ -194,11 +198,30 @@ class CheckHub:
                     logger.debug("Provider set failure details:", exc_info=True)
                     all_errors.append((ps, e))
 
-        logger.info(
-            "Measurement complete: %d metrics calculated, %d errors",
-            len(all_metrics),
-            len(all_errors),
-        )
+        if all_errors:
+            failed_contexts = []
+            for ps, _ in all_errors:
+                tags = {
+                    k: v
+                    for p in ps
+                    if p.is_tag_provider()
+                    for k, v in p.provide().items()
+                }
+                failed_contexts.append(
+                    tags if tags else {"providers": [p.name for p in ps]}
+                )
+            failed_contexts_str = "\n  ".join(str(ctx) for ctx in failed_contexts)
+            logger.info(
+                "Measurement complete: %d metrics calculated, %d failed contexts:\n  %s",
+                len(all_metrics),
+                len(all_errors),
+                failed_contexts_str,
+            )
+        else:
+            logger.info(
+                "Measurement complete: %d metrics calculated",
+                len(all_metrics),
+            )
         return MeasurementResult(
             metrics=all_metrics,
             direct_metric_names=direct_metric_names,