up

src/Scanner/StellaOps.Scanner.Worker/Diagnostics/ScannerWorkerInstrumentation.cs

@@ -1,15 +1,15 @@
-using System.Diagnostics;
-using System.Diagnostics.Metrics;
-
-namespace StellaOps.Scanner.Worker.Diagnostics;
-
-public static class ScannerWorkerInstrumentation
-{
-    public const string ActivitySourceName = "StellaOps.Scanner.Worker.Job";
-
-    public const string MeterName = "StellaOps.Scanner.Worker";
-
-    public static ActivitySource ActivitySource { get; } = new(ActivitySourceName);
-
-    public static Meter Meter { get; } = new(MeterName, version: "1.0.0");
-}
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+
+namespace StellaOps.Scanner.Worker.Diagnostics;
+
+public static class ScannerWorkerInstrumentation
+{
+    public const string ActivitySourceName = "StellaOps.Scanner.Worker.Job";
+
+    public const string MeterName = "StellaOps.Scanner.Worker";
+
+    public static ActivitySource ActivitySource { get; } = new(ActivitySourceName);
+
+    public static Meter Meter { get; } = new(MeterName, version: "1.0.0");
+}

src/Scanner/StellaOps.Scanner.Worker/Diagnostics/ScannerWorkerMetrics.cs

@@ -3,18 +3,20 @@ using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using StellaOps.Scanner.Surface.Secrets;
 using StellaOps.Scanner.Worker.Processing;
-
-namespace StellaOps.Scanner.Worker.Diagnostics;
-
-public sealed class ScannerWorkerMetrics
-{
-    private readonly Histogram<double> _queueLatencyMs;
-    private readonly Histogram<double> _jobDurationMs;
+
+namespace StellaOps.Scanner.Worker.Diagnostics;
+
+public sealed class ScannerWorkerMetrics
+{
+    private readonly Histogram<double> _queueLatencyMs;
+    private readonly Histogram<double> _jobDurationMs;
     private readonly Histogram<double> _stageDurationMs;
     private readonly Counter<long> _jobsCompleted;
     private readonly Counter<long> _jobsFailed;
     private readonly Counter<long> _languageCacheHits;
     private readonly Counter<long> _languageCacheMisses;
+    private readonly Counter<long> _osCacheHits;
+    private readonly Counter<long> _osCacheMisses;
     private readonly Counter<long> _registrySecretRequests;
     private readonly Histogram<double> _registrySecretTtlSeconds;
     private readonly Counter<long> _surfaceManifestsPublished;
@@ -22,21 +24,21 @@ public sealed class ScannerWorkerMetrics
     private readonly Counter<long> _surfaceManifestFailures;
     private readonly Counter<long> _surfacePayloadPersisted;
     private readonly Histogram<double> _surfaceManifestPublishDurationMs;
-
-    public ScannerWorkerMetrics()
-    {
-        _queueLatencyMs = ScannerWorkerInstrumentation.Meter.CreateHistogram<double>(
-            "scanner_worker_queue_latency_ms",
-            unit: "ms",
-            description: "Time from job enqueue to lease acquisition.");
-        _jobDurationMs = ScannerWorkerInstrumentation.Meter.CreateHistogram<double>(
-            "scanner_worker_job_duration_ms",
-            unit: "ms",
-            description: "Total processing duration per job.");
-        _stageDurationMs = ScannerWorkerInstrumentation.Meter.CreateHistogram<double>(
-            "scanner_worker_stage_duration_ms",
-            unit: "ms",
-            description: "Stage execution duration per job.");
+
+    public ScannerWorkerMetrics()
+    {
+        _queueLatencyMs = ScannerWorkerInstrumentation.Meter.CreateHistogram<double>(
+            "scanner_worker_queue_latency_ms",
+            unit: "ms",
+            description: "Time from job enqueue to lease acquisition.");
+        _jobDurationMs = ScannerWorkerInstrumentation.Meter.CreateHistogram<double>(
+            "scanner_worker_job_duration_ms",
+            unit: "ms",
+            description: "Total processing duration per job.");
+        _stageDurationMs = ScannerWorkerInstrumentation.Meter.CreateHistogram<double>(
+            "scanner_worker_stage_duration_ms",
+            unit: "ms",
+            description: "Stage execution duration per job.");
         _jobsCompleted = ScannerWorkerInstrumentation.Meter.CreateCounter<long>(
             "scanner_worker_jobs_completed_total",
             description: "Number of successfully completed scan jobs.");
@@ -49,6 +51,12 @@ public sealed class ScannerWorkerMetrics
         _languageCacheMisses = ScannerWorkerInstrumentation.Meter.CreateCounter<long>(
             "scanner_worker_language_cache_misses_total",
             description: "Number of language analyzer cache misses encountered by the worker.");
+        _osCacheHits = ScannerWorkerInstrumentation.Meter.CreateCounter<long>(
+            "scanner_worker_os_cache_hits_total",
+            description: "Number of OS analyzer cache hits encountered by the worker.");
+        _osCacheMisses = ScannerWorkerInstrumentation.Meter.CreateCounter<long>(
+            "scanner_worker_os_cache_misses_total",
+            description: "Number of OS analyzer cache misses encountered by the worker.");
         _registrySecretRequests = ScannerWorkerInstrumentation.Meter.CreateCounter<long>(
             "scanner_worker_registry_secret_requests_total",
             description: "Number of registry secret resolution attempts performed by the worker.");
@@ -72,28 +80,28 @@ public sealed class ScannerWorkerMetrics
             "scanner_worker_surface_manifest_publish_duration_ms",
             unit: "ms",
             description: "Duration in milliseconds to persist and publish surface manifests.");
-    }
-
-    public void RecordQueueLatency(ScanJobContext context, TimeSpan latency)
-    {
-        if (latency <= TimeSpan.Zero)
-        {
-            return;
-        }
-
-        _queueLatencyMs.Record(latency.TotalMilliseconds, CreateTags(context));
-    }
-
-    public void RecordJobDuration(ScanJobContext context, TimeSpan duration)
-    {
-        if (duration <= TimeSpan.Zero)
-        {
-            return;
-        }
-
-        _jobDurationMs.Record(duration.TotalMilliseconds, CreateTags(context));
-    }
-
+    }
+
+    public void RecordQueueLatency(ScanJobContext context, TimeSpan latency)
+    {
+        if (latency <= TimeSpan.Zero)
+        {
+            return;
+        }
+
+        _queueLatencyMs.Record(latency.TotalMilliseconds, CreateTags(context));
+    }
+
+    public void RecordJobDuration(ScanJobContext context, TimeSpan duration)
+    {
+        if (duration <= TimeSpan.Zero)
+        {
+            return;
+        }
+
+        _jobDurationMs.Record(duration.TotalMilliseconds, CreateTags(context));
+    }
+
     public void RecordStageDuration(ScanJobContext context, string stage, TimeSpan duration)
     {
         if (duration <= TimeSpan.Zero)
@@ -103,12 +111,12 @@ public sealed class ScannerWorkerMetrics
 
         _stageDurationMs.Record(duration.TotalMilliseconds, CreateTags(context, stage: stage));
     }
-
-    public void IncrementJobCompleted(ScanJobContext context)
-    {
-        _jobsCompleted.Add(1, CreateTags(context));
-    }
-
+
+    public void IncrementJobCompleted(ScanJobContext context)
+    {
+        _jobsCompleted.Add(1, CreateTags(context));
+    }
+
     public void IncrementJobFailed(ScanJobContext context, string failureReason)
     {
         _jobsFailed.Add(1, CreateTags(context, failureReason: failureReason));
@@ -124,6 +132,16 @@ public sealed class ScannerWorkerMetrics
         _languageCacheMisses.Add(1, CreateTags(context, analyzerId: analyzerId));
     }
 
+    public void RecordOsCacheHit(ScanJobContext context, string analyzerId)
+    {
+        _osCacheHits.Add(1, CreateTags(context, analyzerId: analyzerId));
+    }
+
+    public void RecordOsCacheMiss(ScanJobContext context, string analyzerId)
+    {
+        _osCacheMisses.Add(1, CreateTags(context, analyzerId: analyzerId));
+    }
+
     public void RecordRegistrySecretResolved(
         ScanJobContext context,
         string secretName,
@@ -253,18 +271,18 @@ public sealed class ScannerWorkerMetrics
             new("scan.id", context.ScanId),
             new("attempt", context.Lease.Attempt),
         };
-
-        if (context.Lease.Metadata.TryGetValue("queue", out var queueName) && !string.IsNullOrWhiteSpace(queueName))
-        {
-            tags.Add(new KeyValuePair<string, object?>("queue", queueName));
-        }
-
-        if (context.Lease.Metadata.TryGetValue("job.kind", out var jobKind) && !string.IsNullOrWhiteSpace(jobKind))
-        {
-            tags.Add(new KeyValuePair<string, object?>("job.kind", jobKind));
-        }
-
-        if (!string.IsNullOrWhiteSpace(stage))
+
+        if (context.Lease.Metadata.TryGetValue("queue", out var queueName) && !string.IsNullOrWhiteSpace(queueName))
+        {
+            tags.Add(new KeyValuePair<string, object?>("queue", queueName));
+        }
+
+        if (context.Lease.Metadata.TryGetValue("job.kind", out var jobKind) && !string.IsNullOrWhiteSpace(jobKind))
+        {
+            tags.Add(new KeyValuePair<string, object?>("job.kind", jobKind));
+        }
+
+        if (!string.IsNullOrWhiteSpace(stage))
         {
             tags.Add(new KeyValuePair<string, object?>("stage", stage));
         }

src/Scanner/StellaOps.Scanner.Worker/Diagnostics/TelemetryExtensions.cs

@@ -1,59 +1,59 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using OpenTelemetry.Metrics;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-using StellaOps.Scanner.Worker.Options;
-
-namespace StellaOps.Scanner.Worker.Diagnostics;
-
-public static class TelemetryExtensions
-{
-    public static void ConfigureScannerWorkerTelemetry(this IHostApplicationBuilder builder, ScannerWorkerOptions options)
-    {
-        ArgumentNullException.ThrowIfNull(builder);
-        ArgumentNullException.ThrowIfNull(options);
-
-        var telemetry = options.Telemetry;
-        if (!telemetry.EnableTelemetry)
-        {
-            return;
-        }
-
-        var openTelemetry = builder.Services.AddOpenTelemetry();
-
-        openTelemetry.ConfigureResource(resource =>
-        {
-            var version = Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "unknown";
-            resource.AddService(telemetry.ServiceName, serviceVersion: version, serviceInstanceId: Environment.MachineName);
-            resource.AddAttributes(new[]
-            {
-                new KeyValuePair<string, object>("deployment.environment", builder.Environment.EnvironmentName),
-            });
-
-            foreach (var kvp in telemetry.ResourceAttributes)
-            {
-                if (string.IsNullOrWhiteSpace(kvp.Key) || kvp.Value is null)
-                {
-                    continue;
-                }
-
-                resource.AddAttributes(new[] { new KeyValuePair<string, object>(kvp.Key, kvp.Value) });
-            }
-        });
-
-        if (telemetry.EnableTracing)
-        {
-            openTelemetry.WithTracing(tracing =>
-            {
-                tracing.AddSource(ScannerWorkerInstrumentation.ActivitySourceName);
-                ConfigureExporter(tracing, telemetry);
-            });
-        }
-
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+using StellaOps.Scanner.Worker.Options;
+
+namespace StellaOps.Scanner.Worker.Diagnostics;
+
+public static class TelemetryExtensions
+{
+    public static void ConfigureScannerWorkerTelemetry(this IHostApplicationBuilder builder, ScannerWorkerOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(options);
+
+        var telemetry = options.Telemetry;
+        if (!telemetry.EnableTelemetry)
+        {
+            return;
+        }
+
+        var openTelemetry = builder.Services.AddOpenTelemetry();
+
+        openTelemetry.ConfigureResource(resource =>
+        {
+            var version = Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "unknown";
+            resource.AddService(telemetry.ServiceName, serviceVersion: version, serviceInstanceId: Environment.MachineName);
+            resource.AddAttributes(new[]
+            {
+                new KeyValuePair<string, object>("deployment.environment", builder.Environment.EnvironmentName),
+            });
+
+            foreach (var kvp in telemetry.ResourceAttributes)
+            {
+                if (string.IsNullOrWhiteSpace(kvp.Key) || kvp.Value is null)
+                {
+                    continue;
+                }
+
+                resource.AddAttributes(new[] { new KeyValuePair<string, object>(kvp.Key, kvp.Value) });
+            }
+        });
+
+        if (telemetry.EnableTracing)
+        {
+            openTelemetry.WithTracing(tracing =>
+            {
+                tracing.AddSource(ScannerWorkerInstrumentation.ActivitySourceName);
+                ConfigureExporter(tracing, telemetry);
+            });
+        }
+
         if (telemetry.EnableMetrics)
         {
             openTelemetry.WithMetrics(metrics =>
@@ -68,38 +68,38 @@ public static class TelemetryExtensions
 
                 ConfigureExporter(metrics, telemetry);
             });
-        }
-    }
-
-    private static void ConfigureExporter(TracerProviderBuilder tracing, ScannerWorkerOptions.TelemetryOptions telemetry)
-    {
-        if (!string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
-        {
-            tracing.AddOtlpExporter(options =>
-            {
-                options.Endpoint = new Uri(telemetry.OtlpEndpoint);
-            });
-        }
-
-        if (telemetry.ExportConsole || string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
-        {
-            tracing.AddConsoleExporter();
-        }
-    }
-
-    private static void ConfigureExporter(MeterProviderBuilder metrics, ScannerWorkerOptions.TelemetryOptions telemetry)
-    {
-        if (!string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
-        {
-            metrics.AddOtlpExporter(options =>
-            {
-                options.Endpoint = new Uri(telemetry.OtlpEndpoint);
-            });
-        }
-
-        if (telemetry.ExportConsole || string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
-        {
-            metrics.AddConsoleExporter();
-        }
-    }
-}
+        }
+    }
+
+    private static void ConfigureExporter(TracerProviderBuilder tracing, ScannerWorkerOptions.TelemetryOptions telemetry)
+    {
+        if (!string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
+        {
+            tracing.AddOtlpExporter(options =>
+            {
+                options.Endpoint = new Uri(telemetry.OtlpEndpoint);
+            });
+        }
+
+        if (telemetry.ExportConsole || string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
+        {
+            tracing.AddConsoleExporter();
+        }
+    }
+
+    private static void ConfigureExporter(MeterProviderBuilder metrics, ScannerWorkerOptions.TelemetryOptions telemetry)
+    {
+        if (!string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
+        {
+            metrics.AddOtlpExporter(options =>
+            {
+                options.Endpoint = new Uri(telemetry.OtlpEndpoint);
+            });
+        }
+
+        if (telemetry.ExportConsole || string.IsNullOrWhiteSpace(telemetry.OtlpEndpoint))
+        {
+            metrics.AddConsoleExporter();
+        }
+    }
+}