Code import - branch release/SIENTIAPDE-1645

2026-08-05 13:53:37 +00:00
commit d481e0acff
116 changed files with 92848 additions and 0 deletions
--- a/tests/test_metrics.py
+++ b/tests/test_metrics.py
@@ -0,0 +1,379 @@
+"""Unit tests for model_manager.metrics module.
+
+This module tests the Prometheus metrics configuration used for
+monitoring and observability in the Sientia DataOps Model Manager.
+"""
+
+
+def test_app_up_metric_exists():
+    """Test that APP_UP metric is properly defined."""
+    from model_manager.metrics import APP_UP
+
+    assert APP_UP is not None
+    assert APP_UP._name == 'app_up'
+    assert (
+        APP_UP._documentation == 'Indicates if the application is running (1) or shutting down (0)'
+    )
+
+
+def test_app_up_metric_has_pod_id_label():
+    """Test that APP_UP metric has pod_id label."""
+    from model_manager.metrics import APP_UP
+
+    assert 'pod_id' in APP_UP._labelnames
+
+
+def test_app_up_metric_is_gauge():
+    """Test that APP_UP is a Gauge metric."""
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import APP_UP
+
+    assert isinstance(APP_UP, Gauge)
+
+
+def test_app_up_metric_can_be_set_to_one():
+    """Test that APP_UP metric can be set to 1 (running)."""
+    from model_manager.metrics import APP_UP
+
+    # Set metric to 1 for a specific pod
+    APP_UP.labels(pod_id='test-pod-1').set(1)
+
+    # Verify the metric value
+    metric_value = APP_UP.labels(pod_id='test-pod-1')._value._value
+    assert metric_value == 1
+
+
+def test_app_up_metric_can_be_set_to_zero():
+    """Test that APP_UP metric can be set to 0 (shutting down)."""
+    from model_manager.metrics import APP_UP
+
+    # Set metric to 0 for a specific pod
+    APP_UP.labels(pod_id='test-pod-2').set(0)
+
+    # Verify the metric value
+    metric_value = APP_UP.labels(pod_id='test-pod-2')._value._value
+    assert metric_value == 0
+
+
+def test_app_up_metric_multiple_pods():
+    """Test that APP_UP metric can track multiple pods independently."""
+    from model_manager.metrics import APP_UP
+
+    # Set different values for different pods
+    APP_UP.labels(pod_id='pod-1').set(1)
+    APP_UP.labels(pod_id='pod-2').set(0)
+    APP_UP.labels(pod_id='pod-3').set(1)
+
+    # Verify each pod has correct value
+    assert APP_UP.labels(pod_id='pod-1')._value._value == 1
+    assert APP_UP.labels(pod_id='pod-2')._value._value == 0
+    assert APP_UP.labels(pod_id='pod-3')._value._value == 1
+
+
+def test_app_up_metric_default_value():
+    """Test that APP_UP metric starts with no value set."""
+    # Create a new label that hasn't been used yet
+    import uuid
+
+    from model_manager.metrics import APP_UP
+
+    unique_pod = f'test-pod-{uuid.uuid4()}'
+
+    # The metric should exist but not have a value until set
+    metric = APP_UP.labels(pod_id=unique_pod)
+    assert metric is not None
+
+
+def test_metrics_module_imports():
+    """Test that metrics module can be imported successfully."""
+    import model_manager.metrics
+
+    assert hasattr(model_manager.metrics, 'APP_UP')
+    assert hasattr(model_manager.metrics, 'Gauge')
+
+
+def test_metrics_module_docstring():
+    """Test that metrics module has proper documentation."""
+    import model_manager.metrics
+
+    assert model_manager.metrics.__doc__ is not None
+    assert 'Prometheus' in model_manager.metrics.__doc__
+    assert 'metrics' in model_manager.metrics.__doc__
+
+
+def test_app_up_metric_can_increment():
+    """Test that APP_UP metric value can be incremented."""
+    from model_manager.metrics import APP_UP
+
+    pod_id = 'test-pod-increment'
+    APP_UP.labels(pod_id=pod_id).set(0)
+
+    # Increment the metric
+    APP_UP.labels(pod_id=pod_id).inc()
+
+    metric_value = APP_UP.labels(pod_id=pod_id)._value._value
+    assert metric_value == 1
+
+
+def test_app_up_metric_can_decrement():
+    """Test that APP_UP metric value can be decremented."""
+    from model_manager.metrics import APP_UP
+
+    pod_id = 'test-pod-decrement'
+    APP_UP.labels(pod_id=pod_id).set(1)
+
+    # Decrement the metric
+    APP_UP.labels(pod_id=pod_id).dec()
+
+    metric_value = APP_UP.labels(pod_id=pod_id)._value._value
+    assert metric_value == 0
+
+
+def test_app_up_metric_set_to_timestamp():
+    """Test that APP_UP metric can be set to current timestamp."""
+    import time
+
+    from model_manager.metrics import APP_UP
+
+    pod_id = 'test-pod-timestamp'
+    current_time = time.time()
+
+    # Set to timestamp
+    APP_UP.labels(pod_id=pod_id).set_to_current_time()
+
+    metric_value = APP_UP.labels(pod_id=pod_id)._value._value
+
+    # Should be close to current time
+    assert abs(metric_value - current_time) < 2  # Within 2 seconds
+
+
+def test_app_up_metric_label_validation():
+    """Test that APP_UP metric validates label names."""
+    from model_manager.metrics import APP_UP
+
+    # Should work with valid label
+    APP_UP.labels(pod_id='valid-pod-name').set(1)
+
+    # Should work with empty string (though not recommended)
+    APP_UP.labels(pod_id='').set(1)
+
+    # Should work with special characters
+    APP_UP.labels(pod_id='pod-123_test.example').set(1)
+
+
+def test_module_exports():
+    """Test that metrics module exports expected symbols."""
+    import model_manager.metrics as metrics_module
+
+    # Check that module has the expected exports
+    module_contents = dir(metrics_module)
+
+    assert 'APP_UP' in module_contents
+    assert 'Gauge' in module_contents
+
+
+def test_app_up_metric_thread_safety():
+    """Test that APP_UP metric is thread-safe."""
+    import threading
+
+    from model_manager.metrics import APP_UP
+
+    pod_id = 'test-pod-threading'
+    APP_UP.labels(pod_id=pod_id).set(0)
+
+    def increment_metric():
+        for _ in range(100):
+            APP_UP.labels(pod_id=pod_id).inc()
+
+    # Create multiple threads that increment the metric
+    threads = [threading.Thread(target=increment_metric) for _ in range(5)]
+
+    for thread in threads:
+        thread.start()
+
+    for thread in threads:
+        thread.join()
+
+    # Should have incremented 500 times total
+    metric_value = APP_UP.labels(pod_id=pod_id)._value._value
+    assert metric_value == 500
+
+
+def test_prometheus_client_gauge_import():
+    """Test that Gauge is properly imported from prometheus_client."""
+    from prometheus_client import Gauge as PrometheusGauge
+
+    from model_manager.metrics import Gauge
+
+    assert Gauge is PrometheusGauge
+
+
+# ---------------------------------------------------------------------------
+# Training metrics — existence, type, and labels
+# ---------------------------------------------------------------------------
+
+_TRAINING_LABEL_NAMES = ('pod_id', 'model_name', 'model_type')
+
+
+def _assert_training_labels(metric):
+    for label in _TRAINING_LABEL_NAMES:
+        assert label in metric._labelnames
+
+
+def test_sientia_training_data_preparation_lag_is_histogram():
+    from prometheus_client import Histogram
+
+    from model_manager.metrics import SIENTIA_TRAINING_DATA_PREPARATION_LAG
+
+    assert isinstance(SIENTIA_TRAINING_DATA_PREPARATION_LAG, Histogram)
+    assert SIENTIA_TRAINING_DATA_PREPARATION_LAG._name == 'sientia_training_data_preparation_lag'
+    _assert_training_labels(SIENTIA_TRAINING_DATA_PREPARATION_LAG)
+
+
+def test_sientia_training_data_preparation_error_count_total_is_counter():
+    from prometheus_client import Counter
+
+    from model_manager.metrics import SIENTIA_TRAINING_DATA_PREPARATION_ERROR_COUNT_TOTAL
+
+    assert isinstance(SIENTIA_TRAINING_DATA_PREPARATION_ERROR_COUNT_TOTAL, Counter)
+    assert 'sientia_training_data_preparation_error_count' in SIENTIA_TRAINING_DATA_PREPARATION_ERROR_COUNT_TOTAL._name
+    _assert_training_labels(SIENTIA_TRAINING_DATA_PREPARATION_ERROR_COUNT_TOTAL)
+
+
+def test_sientia_training_model_fit_lag_is_histogram():
+    from prometheus_client import Histogram
+
+    from model_manager.metrics import SIENTIA_TRAINING_MODEL_FIT_LAG
+
+    assert isinstance(SIENTIA_TRAINING_MODEL_FIT_LAG, Histogram)
+    assert SIENTIA_TRAINING_MODEL_FIT_LAG._name == 'sientia_training_model_fit_lag'
+    _assert_training_labels(SIENTIA_TRAINING_MODEL_FIT_LAG)
+
+
+def test_sientia_training_model_fit_error_count_total_is_counter():
+    from prometheus_client import Counter
+
+    from model_manager.metrics import SIENTIA_TRAINING_MODEL_FIT_ERROR_COUNT_TOTAL
+
+    assert isinstance(SIENTIA_TRAINING_MODEL_FIT_ERROR_COUNT_TOTAL, Counter)
+    assert 'sientia_training_model_fit_error_count' in SIENTIA_TRAINING_MODEL_FIT_ERROR_COUNT_TOTAL._name
+    _assert_training_labels(SIENTIA_TRAINING_MODEL_FIT_ERROR_COUNT_TOTAL)
+
+
+def test_sientia_training_model_quality_mse_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_MODEL_QUALITY_MSE
+
+    assert isinstance(SIENTIA_TRAINING_MODEL_QUALITY_MSE, Gauge)
+    assert SIENTIA_TRAINING_MODEL_QUALITY_MSE._name == 'sientia_training_model_quality_mse'
+    _assert_training_labels(SIENTIA_TRAINING_MODEL_QUALITY_MSE)
+
+
+def test_sientia_training_model_quality_mae_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_MODEL_QUALITY_MAE
+
+    assert isinstance(SIENTIA_TRAINING_MODEL_QUALITY_MAE, Gauge)
+    assert SIENTIA_TRAINING_MODEL_QUALITY_MAE._name == 'sientia_training_model_quality_mae'
+    _assert_training_labels(SIENTIA_TRAINING_MODEL_QUALITY_MAE)
+
+
+def test_sientia_training_model_quality_r2_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_MODEL_QUALITY_R2
+
+    assert isinstance(SIENTIA_TRAINING_MODEL_QUALITY_R2, Gauge)
+    assert SIENTIA_TRAINING_MODEL_QUALITY_R2._name == 'sientia_training_model_quality_r2'
+    _assert_training_labels(SIENTIA_TRAINING_MODEL_QUALITY_R2)
+
+
+def test_sientia_training_dataset_train_rows_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_DATASET_TRAIN_ROWS
+
+    assert isinstance(SIENTIA_TRAINING_DATASET_TRAIN_ROWS, Gauge)
+    assert SIENTIA_TRAINING_DATASET_TRAIN_ROWS._name == 'sientia_training_dataset_train_rows'
+    _assert_training_labels(SIENTIA_TRAINING_DATASET_TRAIN_ROWS)
+
+
+def test_sientia_training_dataset_val_rows_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_DATASET_VAL_ROWS
+
+    assert isinstance(SIENTIA_TRAINING_DATASET_VAL_ROWS, Gauge)
+    assert SIENTIA_TRAINING_DATASET_VAL_ROWS._name == 'sientia_training_dataset_val_rows'
+    _assert_training_labels(SIENTIA_TRAINING_DATASET_VAL_ROWS)
+
+
+def test_sientia_training_model_trained_total_is_counter():
+    from prometheus_client import Counter
+
+    from model_manager.metrics import SIENTIA_TRAINING_MODEL_TRAINED_TOTAL
+
+    assert isinstance(SIENTIA_TRAINING_MODEL_TRAINED_TOTAL, Counter)
+    assert 'sientia_training_model_trained' in SIENTIA_TRAINING_MODEL_TRAINED_TOTAL._name
+    _assert_training_labels(SIENTIA_TRAINING_MODEL_TRAINED_TOTAL)
+
+
+def test_sientia_training_feature_count_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_FEATURE_COUNT
+
+    assert isinstance(SIENTIA_TRAINING_FEATURE_COUNT, Gauge)
+    assert SIENTIA_TRAINING_FEATURE_COUNT._name == 'sientia_training_feature_count'
+    _assert_training_labels(SIENTIA_TRAINING_FEATURE_COUNT)
+
+
+def test_sientia_training_info_is_gauge():
+    from prometheus_client import Gauge
+
+    from model_manager.metrics import SIENTIA_TRAINING_INFO
+
+    assert isinstance(SIENTIA_TRAINING_INFO, Gauge)
+    assert SIENTIA_TRAINING_INFO._name == 'sientia_training_info'
+
+    expected_labels = {
+        'pod_id', 'model_name', 'model_type',
+        'dataset_train_rows', 'dataset_val_rows', 'feature_count',
+        'mse', 'mae', 'r2',
+    }
+    assert expected_labels == set(SIENTIA_TRAINING_INFO._labelnames)
+
+
+def test_sientia_training_info_set_value():
+    import time
+
+    from model_manager.metrics import SIENTIA_TRAINING_INFO
+
+    ts = time.time() * 1000
+    SIENTIA_TRAINING_INFO.labels(
+        pod_id='test-pod',
+        model_name='my_model',
+        model_type='linear',
+        dataset_train_rows='1000',
+        dataset_val_rows='200',
+        feature_count='5',
+        mse='0.01',
+        mae='0.08',
+        r2='0.95',
+    ).set(ts)
+
+    value = SIENTIA_TRAINING_INFO.labels(
+        pod_id='test-pod',
+        model_name='my_model',
+        model_type='linear',
+        dataset_train_rows='1000',
+        dataset_val_rows='200',
+        feature_count='5',
+        mse='0.01',
+        mae='0.08',
+        r2='0.95',
+    )._value._value
+    assert abs(value - ts) < 2000