carverauto/serviceradar
58.8
Adequate · 13 November 2026
1291.3k
lines of production code
Elixir
with Go, Rust
6
measurements over time
What this system is
Features
Add Bazel integration for TLA+ model checking with property-based test validation
Users can now run TLA+ model checks directly as Bazel tests using the new \tlc\_test\ macro. This change introduces a Python driver (\tlc\_driver.py\) and a Bazel macro (\tlc.bzl\) that execute the TLC tool and validate results by checking both the exit status and the specific invariant or action property reported as violated. The build rules include a self-test suite in \build/tla/selftest\ to verify that the toolchain correctly distinguishes between successful model checks, invariant violations, and action property violations.
build/tla · high confidence
Add aarch64 NEON optimizations and libc utility scripts to vendored dependencies
The vendored \memchr\ library now includes architecture-specific implementations for aarch64, utilizing 128-bit NEON vector instructions to accelerate byte searching and counting operations when the hardware feature is available, with automatic fallback to generic scalar routines otherwise. Additionally, a new Python utility script (\libc-util.py\) has been added to the \libc\ vendor directory to assist with development tasks such as checking build targets, managing changelogs, and handling pull request backports.
_python, third\_party/netprobe\_ebpf\vendor/memchr-2.8.1 · high confidence
Add example on-premises environment configuration for ServiceRadar
An example on-premises environment configuration for the 'untd' instance has been added to the ServiceRadar configuration system. This includes a Bazel build file that exposes the configuration and a textproto file defining default connection settings for PostgreSQL, NATS, the core service, and Dgraph. This change allows the on-premises deployment path to be validated by the same build-time tests as CI and SaaS environments, ensuring configuration integrity without exposing real customer data or secrets.
config/environments/onprem · high confidence
Added Bazel project view configuration
A new .bazelproject file has been added to the .bazelbsp directory to configure the Bazel plugin. This configuration enables automatic target derivation from directories and sets the current directory as the project root, allowing the IDE to better understand the Bazel workspace structure.
.bazelbsp · high confidence
Added Elixir and Rust bindings for the ServiceRadar configuration schema
This change introduces the generated Elixir and Rust bindings for the ServiceRadar configuration schema, enabling the application to parse and validate configuration data using the unified protocol buffer definitions. The Elixir bindings (config.pb.ex and rules.pb.ex) expose types for environment kinds (including DEMO), TLS modes, security modes, and a comprehensive rule set for configuration validation (e.g., RequiredIf, ForbiddenIf). The Rust bindings provide a cross-language contract for these types, ensuring consistency with Go, and include tests to verify that unset fields are correctly reported as absent rather than defaulted, and that enum zero values serve as unspecified sentinels.
_config/proto\bindings/elixir · high confidence
Added daisyUI vendor bundle for CSS theming
The web client now includes the daisyUI component library as a vendored JavaScript bundle (\daisyui.js\ and \daisyui-theme.js\). This adds support for applying pre-built UI themes (such as light, dark, cupcake, and synthwave) to the application's interface via CSS variables, enabling consistent styling across components without requiring external CDN dependencies at runtime.
elixir/web-ng/assets/vendor · high confidence
Added wrappers.proto and Bazel build rules for primitive type wrappers
The google/protobuf location now includes the wrappers.proto definition and its corresponding Bazel build configuration. This adds support for wrapper messages (DoubleValue, FloatValue, Int64Value, UInt64Value, Int32Value, UInt32Value, BoolValue, StringValue, and BytesValue) that allow primitive types to be distinguished from their default values, which is useful for embedding in google.protobuf.Any or when presence detection is required.
google · high confidence
CI check for Ecto migration collisions against staging
Added a new CI check that prevents merge conflicts in Ecto migrations by validating the merge of a pull request against the latest staging branch. The tool scans the merged migration directory for duplicate version numbers, duplicate module names, or byte-identical files, failing the build if any collisions are detected to ensure schema-manifest generation remains stable.
_build/migration\collision · high confidence
CI now skips integration actions for documentation-only changes
The CI pipeline in build/ci now detects when a pull request contains only documentation changes (files under docs/, openspec/, or root .md files, excluding build/defs and specific exclusions) and skips the core and web-ng database integration actions entirely. This is implemented via new Python modules (detect\_docs\_only.py, select\_integration\_actions.py) and their associated Bazel build targets (BUILD.bazel), which write skip markers to prevent unnecessary test execution. Additionally, new git metadata validation (git\_metadata.py) and checkout regression tests (git\_checkout\_regression.py) ensure submodule integrity during CI runs.
build/ci · high confidence
Config validation engine added in Elixir and Go alongside existing Rust implementation
The config/manager\_validator area now includes Elixir and Go implementations of the configuration validation engine, in addition to the existing Rust implementation. These new implementations validate configuration instances against the committed rule set (defined in //config/rules) and are verified for correctness through shared conformance vectors and property-based tests. This ensures that all three language implementations produce identical validation results for the same inputs, preventing drift between the different service components that rely on this validation logic.
_config/manager\validator · high confidence
Consolidated packaging infrastructure and native add-on delivery model
The build system has been consolidated into a single \setup-package.sh\ script and a \components.json\ configuration, replacing the previous scattered shell scripts to build both Debian and RPM packages for all ServiceRadar components. This change introduces a new \os-package\ delivery model for native agent add-ons, allowing them to be packaged as dormant \.deb\/\.rpm\ files that are activated by the agent rather than the package manager. The agent package itself has been updated to support ARM64 Linux and includes a new \srctl\ CLI binary with RFC 8628 authentication, while the macOS installer now supports signed builds with improved error reporting for signing failures.
build/packaging · high confidence
Edge anomaly detection add-on with persistent state and CUSUM drift detection
The \rust/anomaly-addon\ introduces a new edge-based anomaly detection add-on that runs per-series detectors directly on the agent. It consumes the local metric feed, normalizes cumulative counters (handling resets, gaps, and 32-bit wraps), and applies rolling z-score scoring with optional hour-of-week seasonal deseasonalization baselines delivered from the core. The add-on now includes a CUSUM drift detector to identify sustained level shifts, configurable checkpoint persistence to survive restarts without cold-starting false positives, and health telemetry to report scoring liveness and dropped telemetry.
rust/anomaly-addon · high confidence
Experimental RDP connector integration via ironrdp
The RDP adapter now includes an experimental connector implementation backed by the ironrdp library. This adds a new backend module that handles the full RDP connection lifecycle, including TCP dialing, TLS verification (supporting both system roots and custom CA bundles), CredSSP authentication, and Kerberos integration. The implementation exposes a probe-gated feature (serviceradar\_rdp\_connector\_link\_probe) that enables live connection handoffs, media frame pumping, and input event mapping, allowing the adapter to establish and maintain active RDP sessions for remote desktop streaming.
rust/rdp-adapter · high confidence
Formal verification of the DIRE device identity and reconciliation engine
Added TLA+ formal models (DireLifecycle and DireResolution) and their associated Bazel test harnesses to formally verify the Device Identity and Reconciliation Engine (DIRE). These models check that the Elixir implementation correctly enforces identity resolution, merge lifecycles, source-id retirement, and the identity fence, ensuring that device records remain unique per physical device and that defects like false merges or stale revivals are prevented.
formal · high confidence
Initial database schema and observability infrastructure for ServiceRadar
This change introduces the foundational database schema for ServiceRadar, establishing the \platform\ schema and bootstroring essential PostgreSQL extensions (pgcrypto, pg\_trgm, citext, timescaledb, and AGE). It creates the core tables for network discovery and topology, including \mapper\_jobs\, \mapper\_topology\_links\, and \sweep\_host\_results\, while also setting up the initial AGE graph \serviceradar\ for graph-based topology queries. Additionally, it provisions the time-series infrastructure for observability by creating hypertables and tables for events, logs, traces, and metrics, and defines configuration profiles for system monitoring (sysmon) and Dusk blockchain node discovery.
_elixir/serviceradar\core/priv/repo/migrations · high confidence
Initial release configuration for ServiceRadar Agent Gateway
This change introduces the initial release environment files for the ServiceRadar Agent Gateway, including systemd service definitions, Erlang VM arguments, and shell environment scripts. The configuration enables mTLS for distributed Erlang node communication, applies specific BEAM performance tuning (such as scheduler capping and busy-wait prevention), and sets up security hardening and resource limits for the gateway service.
_elixir/serviceradar\_agent\gateway/rel · high confidence
Initialize ServiceRadar Core Elixir configuration
This change introduces the initial configuration files for the new Elixir-based ServiceRadar Core application. It defines the base settings for Ash domains (including new resources like Camera, CompositeChecks, and Notifications), configures the Ecto repository, and sets up the Spark code formatter. Production-specific settings in prod.exs switch the Swoosh email client to Req to avoid HTTP/2 conflicts and default the logger to :info to prevent self-telemetry storms. The runtime configuration (runtime.exs) wires up ingestion lane memory budgets, availability evidence capture, and automation callback grants via environment variables, while test.exs disables background jobs and the database for CI.
_elixir/serviceradar\_agent\_gateway/config, elixir/serviceradar\_core\elx/config · high confidence
Initialize ServiceRadar release configuration with TLS and scheduler tuning
This change introduces the initial release environment files for ServiceRadar, enabling secure distributed node communication and optimized VM performance. It adds an environment script (env.sh.eex) that configures the release node name and enables mutual TLS for inter-node distribution when a cluster TLS configuration is present, alongside an example SSL configuration file (ssl\_dist.conf.example) detailing certificate requirements and generation steps. Additionally, it provides VM arguments (vm.args.eex) that cap Erlang schedulers to a 2-core cgroup quota to prevent busy-wait spinning and migration stalls, while increasing process, port, and atom limits to support large clusters.
elixir/web-ng/rel · high confidence
Initializes ServiceRadar backend infrastructure and WASM execution engine
This change introduces the foundational components for the ServiceRadar feature within the web-ng application. It adds a new Rust-based WASM module (\god\_view\_exec\) that exposes C-compatible functions for memory management, computing state visibility masks, calculating three-hop network connectivity, and performing coordinate interpolation. Additionally, it establishes the backend scaffolding by adding default Ecto error message translations and a database seeding script that ensures a default admin user is created upon deployment.
_elixir/web-ng/assets/wasm/god\_view\exec, elixir/web-ng/priv/gettext, elixir/web-ng/priv/repo · high confidence
Introduce @carverauto/serviceradar-cli with dashboard dev harness and edge onboarding
The ServiceRadar developer CLI is now a standalone npm package (\@carverauto/serviceradar-cli\) with its own changelog, build configuration, and documentation. It provides a complete dashboard authoring loop (\init\, \build\, \dev\, \validate\, \publish\) and a local development harness that supports offline testing via fixtures, including mock camera streams, action/event replay, and SRQL query resolution. The CLI also introduces edge onboarding commands (\edge install\, \edge site\, \collector\) and manages authentication with PKCE support. A legacy \serviceradar-dashboard\ bin is preserved as a transitional alias that delegates to the new CLI.
js · high confidence
Introduce ARC custom GitHub Actions runner and Harden Demo GitOps Deployments
This change introduces a custom GitHub Actions Runner Controller (ARC) setup in the \k8s/arc\ directory, providing a dedicated \arc-systems\ namespace and Helm values for a custom runner image (\ghcr.io/carverauto/arc-runner\) that includes essential build tools (cmake, protoc, etc.) missing from the stock GitHub runner. Additionally, it establishes ArgoCD Application manifests for the demo environment: \demo-prod.yaml\ is configured to deploy from the immutable \demo/prod-release\ branch with auto-sync enabled but pruning and self-healing disabled to prevent accidental drift, while \demo-staging.yaml\ is switched to use a pinned Helm chart version (\1.2.11\) from the Harbor registry instead of a moving branch, ensuring reproducible staging deployments.
k8s · high confidence
Introduce Bazel build system for WASM plugins
The build system for WASM plugins has been migrated to Bazel, introducing a new \build/wasm\_plugins\ directory that manages the entire lifecycle of plugin artifacts. This change adds a declarative inventory of plugins (including AWX, Proxmox, NetBox, and OTX) and defines build targets that compile Go and TinyGo sources into WASM binaries. It also introduces a Python-based bundle assembler that packages plugins into signed ZIP archives with metadata, and a publishing script that pushes these bundles to OCI registries using \oras\. The build infrastructure includes platform-specific TinyGo toolchain selection (supporting macOS and Linux on amd64/arm64) and comprehensive test coverage for the bundle assembly, publishing logic, and AWX runtime behavior.
_build/wasm\plugins · high confidence
Introduce Bumblebee Exposure Scanner add-on
Adds the Bumblebee native add-on, which deploys a root-owned local exposure scanner for developer and package-manager artifacts. The add-on installs a systemd timer that runs the scanner periodically, writing sanitized findings to a spool directory for ingestion by the non-root agent. Configuration is managed via a JSON schema and runtime profile, with the service hardened using strict systemd protections and SELinux relabeling to ensure execution under strict security policies.
addons/bumblebee-scan · high confidence
Introduce Elixir datasvc client for NATS JetStream KV operations
The datasvc location now provides an Elixir library that acts as a gRPC client for the ServiceRadar datasvc service, enabling access to a NATS JetStream key-value store. Consumers can use the new Datasvc module to establish connections (with optional mTLS) and perform KV operations such as listing keys, retrieving values, and fetching store metadata via the Datasvc.KV module. The change also includes the necessary protobuf definitions for the KV service and configures the Bazel build to compile the app as a production release while excluding dev-only tooling from the final artifact.
elixir/datasvc · high confidence
Introduce FieldSurvey iOS app for RF and spatial mapping
The FieldSurvey iOS application is introduced, enabling users to conduct Wi-Fi and Bluetooth RF surveys alongside 3D spatial mapping. The app leverages LiDAR and the RoomPlan framework to capture room meshes and floorplans, while simultaneously collecting Wi-Fi signal strength and access point location data. It supports backend integration for uploading survey artifacts, including USDZ meshes, point clouds, and GeoJSON floorplans, and provides a live heatmap visualization of signal coverage.
swift · high confidence
Introduce OTLP Collector Add-on with Agent-Forward Spooling
Added the \serviceradar-otel-addon\, a new native agent add-on that packages the ServiceRadar OTLP collector. This add-on enforces an agent-forward output backend by default, using a durable spool to buffer telemetry frames before relaying them to the agent via the \otlp-relay:v1\ capability. It includes a spool monitor that tracks utilization and emits OCSF usage events (native-telemetry:v1) when thresholds are crossed, and reports degraded health if the spool exceeds 90% capacity or if listeners fail to start.
rust/otel-addon · high confidence
Introduce Palisade: shared SSRF defense primitives for Elixir
The \elixir/palisade\ library has been extracted as the canonical home for shared trust-boundary primitives previously duplicated across ServiceRadar and CRM codebases. It provides \Palisade.NetworkAddressPolicy\ to reject loopback, link-local, and private CIDR addresses (including DNS rebinding protection), \Palisade.OutboundURLPolicy\ to enforce HTTPS-only, public-host URL validation with configurable port allowlists, and \Palisade.OutboundFetch\ to execute HTTP requests bound to pre-validated IPs while preserving TLS hostname verification. The library is published to hex.pm and includes comprehensive test coverage for these security policies.
elixir/palisade · high confidence
Introduce PowerDNS native telemetry addon
A new PowerDNS addon has been added to the ServiceRadar platform, enabling native telemetry ingestion for DNS activity. This component listens for PowerDNS events, processes them into structured telemetry batches, and exposes health and configuration endpoints via the addon SDK, allowing users to monitor PowerDNS infrastructure directly within the platform.
rust/powerdns · high confidence
Introduce Rust SecretManager with strict declaration enforcement and redaction
The Rust configuration library now includes a SecretManager that resolves secrets via a provider selected by the SERVICAR\_ENV environment variable (EnvProvider for non-local environments, FileProvider for localhost). Secrets are wrapped in a Secret type that redacts values in Debug/Display output and requires explicit exposure. A Manifest enforces least-privilege by refusing any secret name not explicitly declared, returning clear errors for undeclared, unresolvable, or provider-failure cases. An in-memory MapProvider is available for testing.
_config/manager\secret/rust · high confidence
Introduce SRQL NIF for native query processing and data encoding
Added a new Rust-based NIF (\srql\_nif\) that enables the Elixir application to execute SRQL queries natively. This component provides functions to parse SRQL queries into Abstract Syntax Trees (AST), translate SRQL queries into SQL (with support for pagination, direction, and OTel signal permissions), and compile bounded interface rates. It also includes a capability to encode query results from JSON into Apache Arrow IPC format, allowing for efficient data transfer between the native layer and the Elixir runtime.
_elixir/serviceradar\_srql/native/srql\nif · high confidence
Introduce SRQL shared library with Rust NIF bindings
Added the \serviceradar\_srql\ Elixir application, which exposes Rust-based Native Implemented Functions (NIFs) for parsing SRQL (ServiceRadar Query Language) queries into abstract syntax trees, translating them to SQL, and encoding/decoding data in Arrow IPC and Cap'n Proto formats. This library serves as a shared component for both the backend (\serviceradar\_core\) and the web layer (\web-ng\), enabling consistent query parsing and data handling across the system.
_elixir/serviceradar\srql · high confidence
Introduce ScaLibr Endpoint Software Inventory scanner addon
Adds the ScaLibr Endpoint Software Inventory addon, which deploys an OSV ScaLibr-backed scanner to generate endpoint software SBOMs and inventory metadata. The addon installs a systemd timer that triggers the scanner hourly, writing results to a shared spool directory for ingestion by the base agent. Configuration allows operators to define scan roots, specific package plugins (dpkg, rpm, apk), and directories to skip, with sensible defaults for security and performance.
addons/scalibr-endpoint-inventory · high confidence
Introduce ServiceRadar BMP collector for BGP monitoring
Adds a new BMP (BGP Monitoring Protocol) collector service that listens for incoming BMP frames, parses them using the arancini-lib library, and publishes structured routing updates to a NATS JetStream stream. The collector normalizes IPv4-mapped IPv6 addresses to standard IPv4 format in its JSON output and supports configurable NATS TLS, credentials, and stream settings.
rust/bmp-collector · high confidence
Introduce ServiceRadar Core configuration and test database safeguards
This change establishes the default configuration for the ServiceRadar Core library, defining baseline settings for Ash, Oban job queues (including cron schedules for maintenance, anomaly, and retention workers), rate-limiting buckets, and observability components like NetFlow and GeoIP. It also introduces a strict test database guard that enforces secure, isolated connections for database-backed tests by validating TLS requirements, restricting allowed database names, and preventing unsafe URL overrides. Also in this area: New scheduled worker and configurable retention for CNPG telemetry and exposure transitions; Introduces Wasm plugin automatic rollout control and refines test SQL logging; Improved sync reliability and addon deduplication safety; Durable alert evaluation with transactional admission and recovery.
_elixir/serviceradar\core/config · high confidence
Introduce ServiceRadar React component library with dashboard and remote access UIs
This change introduces a new \serviceradar-react-components\ library (located in \elixir/web-ng/assets/component\) that bundles a set of React components for the ServiceRadar product. The library pins React to version 19.2.8 and includes a \bun.lock\ dependency manifest. It exports several new UI components: a \JdmEditor\ for visual decision model editing, a \DashboardBuilderCanvas\ for grid-based dashboard authoring, and \DashboardPanelChart\ for rendering charts using Recharts. Additionally, it provides a suite of remote access components, including \RemoteAccessSSHConsole\, \RemoteAccessApplication\, \RemoteAccessDesktopSession\, \RemoteAccessTCPText\, and \RemoteAccessTerminal\, enabling SSH, RDP, and TCP-based remote sessions directly in the browser.
elixir/web-ng/assets/component · high confidence
Introduce ServiceRadar flow collector with multi-protocol support and host-slice attribution
The flow-collector component has been rewritten to support NetFlow (v5, v9, IPFIX) and sFlow ingestion, enabling per-listener bounded channels to isolate noisy protocols and prevent starvation. It now supports host-slice flow attribution, allowing flows to be routed to specific agent subjects based on IP matching and an allowlist. A shared NATS KV template store is available for multi-pod template sharing, and sampling rates are persisted with configurable defaults and per-exporter overrides.
rust/flow-collector · high confidence
Introduce ServiceRadar rperf gRPC checker for network performance testing
The rperf-client component is introduced as a new gRPC service that orchestrates network performance tests against configured targets. It supports mTLS and SPIFFE-based security modes, allowing users to define test targets with specific protocols (TCP/UDP), bandwidth, and duration parameters. The service runs scheduled tests via a poller, parses rperf output to report metrics like throughput and packet loss, and exposes these results through a gRPC interface for integration with the ServiceRadar monitoring system.
rust/rperf-client · high confidence
Introduce ServiceRadar secret management library for Elixir
Added a new Elixir library (ServiceradarSecret) that manages component secrets through a provider-based system. The library enforces least-privilege access by requiring components to declare their required secrets in a manifest before resolution; any attempt to access an undeclared secret is refused immediately to prevent information leakage. It supports two provider backends: EnvProvider, which reads secrets from environment variables (the primary method for Kubernetes and CI environments), and FileProvider, which reads from mounted files (used for local development). The library includes utilities for defining secret names, resolving values securely using closures to prevent accidental logging, and handling errors with clear, specific messages.
_config/manager\secret/elixir · high confidence
Introduce Zen NIF for rule evaluation with caching
Added a new Rust-based NIF (zen\_nif) that exposes a BEAM-compatible interface for evaluating Zen decision rules. The implementation allows Elixir code to pass context JSON and a list of rules to a native function, which builds a decision engine, executes the rules, and merges the results back into the context. To improve performance, the native layer caches compiled engines keyed by a hash of the rule set, avoiding redundant construction for identical rule configurations. The build system has been updated to compile this NIF using Bazel with rules\_rs, ensuring hermetic LLVM usage and static linking of the C++ runtime to prevent shared-object resolution issues on macOS.
_elixir/serviceradar\_core/native/zen\nif · high confidence
Introduce adaptive RF scanning and secure API for FieldSurvey Sidekick
The FieldSurvey Sidekick service now supports adaptive channel hopping, which dynamically prioritizes frequencies based on real-time spectrum and RF observations to improve scan efficiency. This capability is exposed via a new REST API (powered by axum) that includes endpoints for observation and spectrum streaming, configuration management, and device pairing. Access to these endpoints is secured using bearer tokens, supporting both a static setup token and dynamically generated pairing tokens for paired devices.
rust/fieldsurvey-sidekick · high confidence
Introduce asynchronous Dgraph NIF with scheduler isolation
Added a new Rust NIF module (\dgraph\_nif\) that offloads Dgraph topology operations to a dedicated Tokio runtime, ensuring that network stalls or long-running queries no longer block BEAM scheduler threads. The implementation introduces asynchronous call handling with explicit deadlines, in-flight concurrency limits for both item-level and bulk operations, and panic isolation to prevent native crashes from taking down the Erlang node. Users benefit from improved system stability and responsiveness, as Dgraph connectivity issues are now contained and do not cause node-wide I/O stalls.
_elixir/serviceradar\_core/native/dgraph\nif · high confidence
Introduce bounded native topology NIF with async reads and admission control
This change adds a new Rust NIF module (\topology\_atlas\_nif\) that exposes bounded, persisted topology world operations to the Elixir side. It introduces an admission gate system to limit concurrent native work (e.g., 16 slots for bounded reads, 4 for tile reads) and ensures permits are retained until work completes, even if the BEAM caller exits. Dgraph topology reads are now asynchronous: the NIF returns immediately with a handle, and the Elixir side receives the result via a message, preventing scheduler stalls. The module also exposes functions for building topology worlds, reading detailed node/relation data, managing device health, and querying device IDs, all backed by bounded resources and revision-aware cursors.
_elixir/serviceradar\_core/native/topology\_atlas\nif · high confidence
Introduce bounded native topology atlas with hierarchical ELK layout and health indexing
The \rust/topology-atlas\ crate now provides a complete, bounded native implementation for topology geometry and detail selection. It replaces previous layout mechanisms with a hierarchical ELK radial engine (\elk.rs\, \elk\_hierarchy.rs\) that executes pinned JavaScript in an isolated 16 MiB thread to preserve geometry and relation semantics across tiles. The system introduces bounded detail selection (\details.rs\) with strict limits on nodes (128), edges (256), and members (64) per selection, ensuring memory safety. It also adds a native health index (\health.rs\) for tracking device availability independent of geometry, and a spatial segment index (\spatial.rs\) for efficient tile intersection queries. The layout reconciliation (\layout.rs\) ensures deterministic placement and component stability across incremental updates.
rust/topology-atlas · high confidence
Introduce immutable schema template manifest generation
Added a new Bazel build target that generates a deterministic manifest of schema inputs (migrations, baseline SQL, helpers, and construction dependencies) using cryptographic hashes. This ensures that schema template generations are reproducible and immutable, with identity changes triggered by any modification to the declared inputs, and includes a policy configuration for controlling generation constraints.
_build/schema\template · high confidence
Introduce in-kernel network flow attribution and L2 device census via eBPF
The netprobe now performs network flow attribution and Layer 2 device discovery directly in the kernel using eBPF programs. This change adds support for tracking TCP, UDP, and ICMP/ICMPv6 flows, including passive L2 device census via ARP and NDP (Neighbor Discovery Protocol). It also introduces p0f signature detection for TCP SYN packets and captures mDNS announcements at the kernel level, reducing reliance on userspace tools like avahi. These in-kernel observations are attributed to local processes and sent to userspace via ring buffers for correlation and reporting.
rust/netprobe/ebpf · high confidence
Introduce native Workload Identity add-on for node-local container metadata enrichment
A new standalone Rust-based add-on has been introduced to collect and enrich node-local workload identity metadata. This component replaces the previous integration within the netprobe, providing a dedicated binary that discovers container runtimes (including Docker, containerd, and CRI-O) via Unix sockets and periodically collects identity snapshots (pod name, namespace, labels, etc.) into a spool directory. A separate validation utility is also included to verify CRI connectivity and identity resolution on the node.
rust/workload-identity · high confidence
Introduce new timeseries dashboard plugin components
The timeseries dashboard plugin has been refactored into a modular structure, introducing dedicated modules for chart rendering (ChartCard, CombinedChartCard), data processing (Metrics, SeriesData, Points, Paths), and specification parsing (Spec). This change adds support for series encodings (shapes like circles, squares, triangles), annotation markers, chart overlays (anomaly windows, capacity confidence bands), and reference lines. It also implements counter rate calculations, unit formatting, and optimized path generation for timeseries visualization.
_elixir/web-ng/lib/serviceradar\_web\_ng\web/dashboard/plugins/timeseries · high confidence
Introduce shared AF\_PACKET capture crate
The \rust/afpacket\ crate provides a unified, Linux-only \AF\_PACKET\ capture engine using \PACKET\_MMAP\ (TPACKET\_V3) rings, replacing the separate ring walkers previously maintained by \serviceradar-netprobe\ and \serviceradar-fieldsurvey-sidekick\. It enforces a strict setup sequence to prevent silent failures—such as building a V1 ring or capturing traffic from unauthorized interfaces—and ensures accurate, monotonic drop statistics by accumulating kernel counters. On non-Linux platforms, the crate fails loudly at runtime rather than returning empty successes, ensuring that capture paths are never indistinguishable from idle interfaces.
rust/afpacket · high confidence
Introduce simkit simulation library and hello-sim demo plugin
Added the \demo/simkit\ library, which provides deterministic simulation capabilities for generating device inventory, metrics, and fault events, along with a \guard\ package to enforce safety rules (e.g., preventing public IP usage). Included the \demo/hello-sim\ demo plugin, which uses simkit to simulate environmental sensors and overheat faults, proving the end-to-end build, bundle, sign, and publish path for WASM plugins. Also added the \sample\ pack and fixture generation tools to support dashboard development with stable, reproducible test data.
demo/simkit · high confidence
Introduce standalone Workload Identity add-on for node-local container metadata collection
A new native add-on has been added to collect and enrich Kubernetes pod, namespace, container, image, and runtime identity data directly on the node. This standalone Rust service runs as root to access CRI/Docker sockets, writes bounded identity snapshots to a local spool directory for the agent to ingest, and includes a systemd unit with strict security hardening (ProtectSystem=strict, SELinux chcon support, no CAP\_DAC\_OVERRIDE). Configuration allows enabling/disabling the collector, specifying CRI or Docker endpoints, setting context/cluster labels, and tuning refresh intervals and snapshot sizes.
addons/workload-identity · high confidence
Introduce unified configuration schema and validation rules for ServiceRadar
ServiceRadar now uses a centralized, language-agnostic configuration system. A new protobuf-based schema (config.proto) defines environment kinds (including a new DEMO mode) and typed TLS settings for PostgreSQL and Dgraph, replacing ambiguous string-based configurations. A corresponding rule set (ruleset.textproto) enforces validation constraints—such as required fields, value ranges, and TLS posture—across Go and Rust implementations, ensuring consistent behavior and preventing silent defaulting errors.
_config/proto\bindings, config/rules · high confidence
Introduce web-ng Elixir application configuration
The web-ng application now includes its own dedicated Elixir configuration files (config.exs, dev.exs, prod.exs, runtime.exs, test.exs). This establishes the web-ng app as a distinct OTP application with its own Phoenix endpoint, Ash domain registrations, and Oban job processing settings. The configuration enforces that web-ng joins the ERTS cluster for distributed reads but explicitly disables hosting distributed processes and joining the Horde CRDT mesh to prevent state bloat during frequent rollouts. It also configures the React build tooling (esbuild), Guardian JWT token lifetimes, and runtime environment variable loading for database connections, OpenTelemetry, and automation callbacks.
elixir/web-ng/config · high confidence
Introduces AF\_XDP-based packet capture and DPI classification pipeline
netprobe now supports high-performance packet capture and Deep Packet Inspection (DPI) using the AF\_XDP kernel interface. This change adds the core runtime plumbing for AF\_XDP, including consumer threads, ring buffer management, and socket registration with eBPF maps. It introduces a new classifier that processes packets from the AF\_XDP stream, performing DPI analysis and updating the eBPF flow table for attribution. This replaces or supplements the previous libpcap-based capture path, enabling lower-latency, high-throughput network visibility for supported Linux kernels.
rust/netprobe · high confidence
Introduces Rust config-bootstrap library for unified configuration loading
The new \rust/config-bootstrap\ crate provides a configuration loading mechanism for ServiceRadar Rust services, mirroring the functionality of the Go \pkg/config/bootstrap\ module. It enables services to load configuration files in JSON or TOML format from disk and apply an optional 'pinned' overlay configuration (specified via the \PINNED\_CONFIG\_PATH\ environment variable) to ensure sensitive values take precedence. This change establishes a unified config loading experience across the Rust component of the ServiceRadar platform.
rust/config-bootstrap · high confidence
Introduces Rust native add-on SDK and reference implementation
Adds a Rust SDK (\addon-sdk\) that allows native agent add-ons to be launched and supervised by the ServiceRadar agent's existing HashiCorp go-plugin client, implementing the plugin server half of the go-plugin wire protocol (stdout handshake, AutoMTLS certificate exchange, and gRPC \AddonService\ over a Unix-domain socket). This enables add-ons to be written in Rust while being treated identically to Go add-ons by the agent. The change includes the SDK library, a reference sample add-on binary, and the underlying protocol definitions (\addon.proto\, \discovery.proto\).
rust · high confidence
Introduces ServiceRadar configuration validation logic
The \ServiceradarConfig.Validator\ module has been added to evaluate committed rule sets against environment instances at load time. This implementation enforces the semantics defined in \config/SEMANTICS.md\, utilizing Elixir's \Regex\ (PCRE) for pattern matching instead of RE2, with conformance vectors ensuring outcome parity. The validator supports a range of predicates including \required\, \non\_empty\, \int\_range\, \one\_of\, \matches\, \required\_if\, \forbidden\_value\, and \forbidden\_if\, and treats rules referencing non-existent fields as hard errors to prevent silent failures.
_config/manager\validator/elixir · high confidence
Introduces dashboard camera streaming and plugin action/event APIs
Adds a new camera relay system for dashboard packages, including a \DashboardCameraApi\ that manages WebRTC and WebCodecs/MSE video sessions with capability-based access control and session limits. Introduces a \DashboardChannelApi\ providing \actions.invoke\ and \events.subscribe\ capabilities for dashboard plugins, enabling host-rendered action confirmations and live event subscriptions. Includes a new \GodViewRenderer\ for WebGPU-based topology visualization and a \PacketFlowLayer\ for rendering animated packet flows on topology edges.
elixir/web-ng/assets/js · high confidence
Introduces plugin assignment change handlers for configuration, policy, and lifecycle management
This change adds a suite of Ash resource change handlers in the \serviceradar/plugins/changes\ directory to enforce data integrity and automate lifecycle behaviors for plugin and add-on assignments. It introduces logic to normalize and apply defaults for add-on configuration parameters and update policies, ensuring consistent data types and appropriate default behaviors based on package provenance. The update also implements automatic retraction of assignments when their owning policies or credential rules are disabled, deleted, or narrowed, and handles the cleanup of active rollout overrides when an assignment is disabled. Additionally, it adds handlers to bind assignments to authenticated agent partitions, reject mutations on legacy unbound or policy-owned records, and manage the issuance and revocation of direct-leaf access credentials.
_elixir/serviceradar\core/lib/serviceradar/plugins/changes · high confidence
Migrate Docker image builds to Bazel with hermetic, multi-arch OCI support
The \docker/images\ directory now uses Bazel to define and build all container images, replacing previous ad-hoc methods. This change introduces hermetic build rules for the \web-ng\, \core-elx\, and \CNPG\ images, ensuring deterministic, byte-identical layers across rebuilds by normalizing timestamps and file ordering. It adds multi-architecture (amd64/arm64) support for key services, including the \web-ng\ and \core-elx\ images, and introduces a new \cnpg-analytics\ image for cold-tier analytics. The build system now includes strict ABI checks for PostgreSQL extensions (TimescaleDB, AGE) to prevent runtime failures caused by glibc version mismatches between the build executor and the runtime base. Additionally, a new \workflow-runner\ image is provided for BuildBuddy, optimized for size and containing only the necessary utilities for CI workflows.
docker/images · high confidence
Native Rust add-on SDK with go-plugin interop
ServiceRadar now supports native Rust add-ons via a new SDK that implements the HashiCorp go-plugin wire protocol. This allows Rust binaries to be launched and supervised by the existing Go agent without host-side changes, using a Unix-domain socket and gRPC. The SDK includes a reference sample add-on, structured health reporting, and support for AutoMTLS (including ECDSA P-521 verification) to ensure secure, byte-for-byte compatibility with the Go plugin client.
rust/addon-sdk · high confidence
Native add-on build, signing, and release gate infrastructure
This change introduces the build and release guardrails for native agent add-ons. It adds a Bazel package that defines the inventory of first-party add-ons (netprobe, PowerDNS, workload identity, Bumblebee, Scalibr, RDP adapter, anomaly, and others) and assembles per-architecture bundles (zip + sha256 + metadata.json) with deterministic, reproducible outputs. A new Go tool signs and verifies these pushed-artifacts using the ServiceRadar agent release ed25519 key, matching the agent's verification contract. The build enforces binary portability by compiling Rust add-ons against musl and validating ELF headers, checks binary sizes against a baseline, ensures dependency isolation so the base agent does not depend on add-on implementations, and validates add-on manifests. These gates run as CI/build checks to prevent invalid or oversized bundles from being published.
_build/native\addons · high confidence
Native prefix-tag snapshot and catalog engine
A new Rust-based native library (prefix\_tags\_nif) is introduced to manage packed prefix-tag snapshots and build reverse catalogs for label discovery. This component provides a high-performance, immutable trie for IPv4/IPv6 prefix lookups and a bounded, resumable catalog builder that prepares label pages and network ranges without blocking the BEAM scheduler. It exposes NIFs for preparing catalogs, querying label pages and ranges, and checking catalog status, enabling efficient, memory-bounded label-based prefix lookups in ServiceRadar.
_elixir/serviceradar\_core/native/prefix\_tags\nif · high confidence
Native topology membership index for the God View
The God View now includes a new Rust-based native interface (NIF) that manages persistent, revision-pinned bitmap membership for topology entities. This index handles dirty ordinal reconciliation, bounded query execution with literal facet/tag prefix support, and typed row overlays for the browser, all while enforcing strict native memory budgets and concurrency limits to ensure stable performance.
_elixir/web-ng/native/god\_view\nif · high confidence
Netprobe delivered as a standalone systemd-supervised add-on
The netprobe host-network-visibility component is now packaged as a native add-on (version 0.2.63) rather than being baked into the base agent. It is installed as a signed pushed-artifact bundle containing a systemd service unit, a JSON configuration schema, and the compiled binary. The service runs as the 'serviceradar' user, requires specific Linux capabilities (CAP\_NET\_RAW, CAP\_NET\_ADMIN, CAP\_BPF, CAP\_PERFMON), and communicates with the agent via a local IPC socket. This change decouples the netprobe lifecycle from the base agent, allowing it to be managed and updated independently.
addons/netprobe · high confidence
New BGP, NetFlow, and Flow visualization chart components
This update introduces a suite of new JavaScript hooks for the charts directory, adding dedicated visualizations for BGP time-series data (BGPTimeSeriesChart), NetFlow grid layouts (NetflowGridChart), and general flow rates (FlowRateChart, FlowSparkline, FlowDonut). These components provide users with interactive time-series plots, grid-based multi-panel views, and summary donut/sparkline charts. The implementation includes robust handling of time zones (displaying localized labels while preserving canonical UTC data), gap handling for null data points, and accessible status updates for range selections.
elixir/web-ng/assets/js/hooks/charts · high confidence
New Bazel build infrastructure for Elixir releases, integration test selection, and benchmark execution
This change introduces a comprehensive Bazel-based build system for the Elixir codebase. It replaces the previous release assembly process with a new \elixir\_release\ rule that supports multi-arch (including arm64) OTP releases by explicitly managing the ERTS. It adds a rigorous integration test selection framework (\integration\_selection\_equivalence\_test\) that validates test manifests against actual ExUnit selections, ensuring CI consistency. Additionally, it introduces a \benchmark\_runner.py\ and associated Bazel rules to actually execute Go and Rust benchmarks (rather than just compiling them) and to fail if no benchmarks run, preventing silent rot. The build also includes hermetic Elixir quality checks (formatting and Credo) running on Remote Build Execution (RBE). Also in this area: Add camera ingest schema generation and update test dispositions; Updated build configuration for new integration tests and release signing; Build system updates for parallel CI and new test coverage.
build · high confidence
New Bazel build rules and tests for agent release packaging
The \build/release\ directory now contains the Bazel build definitions and Go source code for the \publish\_packages\ release tool. This includes new rules to build the publishing binary and its tests, along with specific test suites that validate the structure and metadata of Linux agent packages (both amd64 and arm64 deb and rpm formats) and verify the integrity of the managed runtime archives. The implementation also introduces logic to handle macOS and Windows installer provenance, ensuring that release artifacts are correctly prepared and validated before upload.
build/release · high confidence
New Dgraph topology service with schema, client, and canonical graph reads
The \rust/dgraph-topology\ crate introduces a new service for managing network topology in Dgraph. It includes a schema migrator (\dgraph-migrate\) to apply a namespaced schema (covering devices, interfaces, hops, prefixes, and topology edges), a typed client (\TopologyClient\) for upserting devices, interfaces, prefixes, and edges, and a canonical graph reader (\canonical\_read\) that performs paginated, transactional reads to handle large datasets safely. The service also provides downstream reachability analysis (\downstream\) and comprehensive error handling (\TopologyError\).
rust/dgraph-topology · high confidence
New Docker Compose infrastructure and service definitions
This change introduces the foundational Docker Compose environment for ServiceRadar, adding build definitions (Dockerfiles) for all core services including the Go-based agent, Elixir core and web interfaces, data services, log collector, and debugging tools. It includes a Caddy reverse-proxy configuration for the web interface, Bazel build rules to expose compose assets, and shell scripts for bootstrapping admin credentials, database users, and CNPG (CloudNativePG) initialization. The entry also adds comprehensive configuration files (JSON) for agent, gateway, and collector services, along with environment examples for the optional cold-tier analytics profile.
docker/compose · high confidence
New Docker build infrastructure and Harbor registry integration
This change introduces a new Remote Build Execution (RBE) executor image (Dockerfile.rbe) based on Ubuntu 24.04, optimized for hermetic builds with specific tooling like Docker CE, PostgreSQL 18 libraries, and SBOM/signing tools (Syft, Cosign). It also adds documentation (LOCAL\_BUILD.md, README.md) and configuration for building and pushing ServiceRadar images to the new Harbor registry (registry.carverauto.dev), replacing previous build and hosting assumptions.
docker · high confidence
New Dockerfiles for building RPM packages for ServiceRadar components
Added a suite of Dockerfiles in the docker/rpm directory to build RPM packages for various ServiceRadar components, including NATS, rperf, BMP collector, profiler, trapd, and generic Go-based components. These files define multi-stage builds using Rocky Linux 9, handling Rust compilation (with specific toolchains like nightly for eBPF or stable for others), Go compilation, and dependency installation (such as protobuf, clang/llvm for eBPF, and capnproto). The builds produce RPMs for components like serviceradar-nats, serviceradar-rperf, serviceradar-bmp-collector, serviceradar-profiler, and serviceradar-trapd, ensuring consistent packaging across different language stacks and component types.
docker/rpm · high confidence
New FieldSurvey local development skill for web-ng
Added a new agent skill that provides scripts and documentation to run the web-ng application locally against the Kubernetes demo namespace's FieldSurvey data. This includes automated setup for CNPG NodePort database access, NATS Object Store port-forwarding, and Playwright-based smoke tests to verify the dashboard, settings preview, and FieldSurvey review page.
.agents/skills/fieldsurvey-local-web-ng · high confidence
New KV utility library for key-value operations and secure client connections
Added a new \kvutil\ Rust crate that provides a \KvClient\ for interacting with a key-value service. The client supports standard get, put, and put-if-absent operations, as well as a watch-apply mechanism for real-time key updates. It handles connection configuration via environment variables, supporting three security modes: no TLS, mutual TLS (mTLS) with explicit certificate files, and SPIFFE-based TLS using a workload socket for identity management.
rust/kvutil · high confidence
New RDP connector probe for validating security boundaries and TLS configuration
The \rust/rdp-connector-probe\ module has been introduced to provide a dedicated testing and validation layer for the RDP connection flow. It parses the \ServiceRadarOpenRequest\ payload and uses the \ironrdp\ library to simulate the RDP handshake, allowing operators to verify that the connector correctly negotiates security protocols (such as CredSSP and NLA) and enforces TLS policies. The probe includes strict validation for CA bundles, ensuring that only PEM-encoded certificates are accepted and raw DER data is rejected with structured errors, and it verifies that credentials are not exposed in cleartext during the initial connection PDU. This tool enables automated checks of the RDP adapter's security posture, including TLS downgrade protection and credential handling, before a live session is established.
rust/rdp-connector-probe · high confidence
New RTSP replayer demo for licensed drone footage
Added a new demo service that serves licensed drone clips as looping RTSP streams. The replayer downloads and verifies clips from an S3 bucket against a locked manifest, then uses MediaMTX and ffmpeg to publish them on port 8554. It includes Bazel build rules for multi-architecture container images and comprehensive tests for clip fetching, lock validation, and S3 signing.
demo/rtsp-replayer · high confidence
New React dashboard templates for ServiceRadar
Added two new CLI templates for ServiceRadar dashboards: a blank template that displays raw JSON results from the primary frame, and a table template that renders paginated, searchable, and filterable device data (including status, model, and last seen) with a dedicated search input and status dropdown.
js/cli/templates/react-blank, js/cli/templates/react-table · high confidence
New React map dashboard template with LOD-based site clustering
The react-map CLI template now provides a map-based dashboard that clusters site markers based on screen-level-of-detail (LOD) to maintain performance at various zoom levels. Users can filter sites by region or search text, and clicking a cluster zooms into its constituent sites. The visualization adapts to dark and light themes, with cluster sizes and colors dynamically adjusting based on the number of access points (APs) and the current zoom state.
js/cli/templates/react-map · high confidence
New Rust NIF for anomaly disposition kernels
Added a new Rust-based NIF (\anomaly\_disposition\_nif\) that exposes seasonal residual-z and capacity forecast disposition kernels to the Elixir BEAM. The NIF provides a typed \dispose\_batch\ entry point that processes rows in bulk, ensuring per-row error isolation so that malformed data or kernel panics do not crash the DirtyCpu scheduler thread. The build system has been updated to compile this NIF using Bazel with \rules\_rs\, statically linking the C++ runtime to ensure portability across environments.
_elixir/serviceradar\_core/native/anomaly\_disposition\nif · high confidence
New Rust edge-onboarding library for ServiceRadar checkers
A new Rust library has been added to the edge-onboarding crate to handle secure agent and checker onboarding. It supports mTLS bootstrap via signed edgepkg-v2 tokens and Core API package downloads, automatic deployment type detection (Docker, Kubernetes, or bare-metal), and generation of sysmon checker configurations. The library manages mTLS certificate installation, token parsing and validation, and provides a structured error model for onboarding failures.
rust/edge-onboarding · high confidence
New Rust-based configuration validator for ServiceRadar
A new Rust library in \config/manager\_validator/rust\ has been introduced to evaluate committed configuration rules against environment instances. This validator parses protobuf text-format configuration files, extracts leaf field paths and enum values directly from the schema descriptor to ensure coverage rules stay in sync with the schema, and scans configuration values for credential-shaped patterns (such as embedded passwords in URLs or high-entropy tokens) to prevent accidental secret exposure. It provides a normative evaluation engine that checks rules against specific environment kinds and phases, ensuring that configuration changes are validated for both structural correctness and security compliance.
_config/manager\validator/rust · high confidence
New Rust-based log ingestion and decoding pipeline in flowgger
The flowgger component now includes a comprehensive Rust implementation for parsing and encoding log data. This adds support for multiple syslog standards (RFC3164, RFC5424) and formats (GELF, LTSV) via a new decoder module that can automatically detect and parse incoming messages. It also introduces a Cap'n Proto encoder for efficient serialization and a TOML-based configuration system to manage input and output settings.
rust/flowgger · high confidence
New ServiceRadar Kubernetes edge sensor chart
A new Helm chart, \serviceradar-k8s-edge\, is available for clusters that do not run the full ServiceRadar platform. It deploys a lightweight \serviceradar-agent\ (outbound mTLS to a central or SaaS \agent-gateway\) and an optional \serviceradar-k8s-inventory\ component that watches the Kubernetes API for public VIP and Gateway ownership. The chart supports cluster-scoped or namespace-scoped RBAC, Gateway API discovery, and publishes inventory data via an \agent\_spool\ path to the central platform.
helm · high confidence
New ServiceRadar binary for extracting environment configuration sections
A new Rust-based tool (\config/tools/rust\) has been introduced to extract specific sections (database, nats, core, or dgraph) from a compiled \EnvironmentConfig\ binary. This utility supports a least-privilege security model by allowing targets to declare exactly which configuration section they require, ensuring that sandboxed processes (such as database tests) do not physically contain unrelated configuration data like NATS settings. The tool reads a protobuf-encoded input file, decodes the full environment config, extracts the requested section, and writes the result to an output file, failing if the section is missing or unknown.
config/tools/rust · high confidence
New build hygiene and release-contract validation scripts
The repository now includes a comprehensive suite of new shell and Python scripts in the \scripts/\ directory to enforce build hygiene, validate release contracts, and manage packaging. These scripts introduce automated gates for native add-on binary size regression, dead-code elimination, and forbidden stdlib plugin usage, ensuring add-ons remain lean and compatible with the host agent. Release workflows are now backed by strict validation scripts that check Helm chart defaults (such as CNPG WAL capacity and core analytics settings), verify OCI publish signatures, and ensure version bumps are correctly reflected in add-on manifests. Additionally, new tooling supports macOS agent packaging with notarization, multi-platform Docker image building, and fixture provisioning for remote-access smoke tests.
scripts · high confidence
New build/buildbuddy release pipeline entry point
A new Bazel build target and shell script have been added to the build/buildbuddy directory to orchestrate the release process. The release\_pipeline.sh script automates the setup of remote execution credentials, ensures required tools like Cosign and ORAS are installed, resolves the release tag from various environment variables or the VERSION file, and executes the container push via Bazel. It also handles post-push signing and verification of OCI images, providing a centralized, reproducible entry point for publishing releases.
build/buildbuddy · high confidence
New built-in dashboards for endpoint inventory, security findings, and service availability
The web interface now includes three new built-in dashboard renderers: Endpoint Inventory, Security Findings, and Service Availability (NOC). The Endpoint Inventory dashboard displays device scan coverage, package rollups, shared CPE exposure, and recent package rows. The Security Findings dashboard aggregates active findings, device correlation, scan activity, and DNS security events, including scanner signal coverage and exposure posture. The Service Availability dashboard shows overall availability, degraded services, SLO risk, and active incidents. All dashboards support user-configurable timezones for timestamp display and include interactive SRQL query links for deeper investigation.
elixir/web-ng/assets/js/dashboards · high confidence
New client-side hooks for device metadata, bulk editing, camera relay, and dashboard controls
This update introduces a suite of new JavaScript hooks in the web-ng frontend to enhance device details, bulk operations, camera streaming, and dashboard interactivity. The AllMetadataCard hook adds client-side filtering and a 'copy as JSON' button to the device metadata view. BulkEditTagsToggle dynamically reveals tag input fields during bulk actions. CameraRelayStatusStream manages WebRTC and MSE-based camera relay playback, handling browser compatibility and reconnection logic. Dashboard hooks (BuilderCanvas, MapViewSelect, PanelChart, WasmHost, WindowSelect) integrate React components for the dashboard builder, manage map view switching, render charts, and handle WASM-based dashboard rendering and time-window preferences. CommandPalette provides a keyboard-driven command interface for the Settings shell. CredentialDeepLinkFocus ensures deep-linked credential rows are scrolled into view and focused. DetailsState preserves the open/closed state of native \<details\> elements across LiveView patches. DialogTopLayer promotes modals to the browser's top layer to ensure they render above the ops sidebar and sticky UI elements.
elixir/web-ng/assets/js/hooks · high confidence
New demo dashboard kit for offline fault simulation
Added a new demo dashboard kit in \demo/dashboard-kit\ that provides a shared React frame and presenter strip for showcasing fault scenarios. The kit includes a \createDemoKit\ factory, a \PresenterStrip\ component that displays active incidents, countdowns to the next scheduled fault, and trigger buttons for plugin actions, and a \useFaultIncidents\ hook for subscribing to fault events. It supports offline authoring and testing via JSON fixtures (\presenter-steady.json\, \presenter-fault.json\) and a Bazel test suite (\kit\_tests\) that validates presenter logic, fixture round-trips, and component renders using stand-in SDK hooks.
demo/dashboard-kit · high confidence
New demo pluginkit and rulecheck packages for plugin development
This change introduces the \pluginkit\ and \rulecheck\ packages within the \demo/pluginkit\ directory to support the demo plugin lifecycle. The \pluginkit\ package provides a standardized way for demo plugins to map simulation data (devices, faults, metrics) into ServiceRadar SDK payloads, handling device discovery, OCSF fault events, and telemetry batching. The \rulecheck\ package allows demo plugins to validate their alert rules against event signals, ensuring that fault events correctly trigger and resolve alerts as defined in the plugin manifest. These additions establish the build, bundle, and validation path for demo plugins.
demo/pluginkit · high confidence
New demo publishing tool for ServiceRadar
A new \demopublish\ tool has been added to the demo tools directory, enabling users to automate the end-to-end publication of a demo plugin to a ServiceRadar instance. This tool handles signing the plugin bundle, staging and uploading the package, approving the release, enabling associated alert rules, assigning the plugin to a specific agent, and optionally publishing and enabling a dashboard package. The implementation includes a comprehensive test suite that mocks the ServiceRadar API to verify idempotency and correct state transitions during the publish workflow.
demo/tools · high confidence
New demo skill for running web-ng against live CNPG database
Added a new agent skill (demo-cnpg-local-web-ng) that provides a script to run the local web-ng application against the live Kubernetes demo CNPG database. This allows users to test the dashboard, SRQL, and UI features using real demo data without relying on fragile kubectl port-forwarding, with automatic fallback to NodePort routes if the internal LoadBalancer VIP is unreachable.
.agents/skills/demo-cnpg-local-web-ng · high confidence
New development and CI precommit scripts for web-ng
Added \bazel\_precommit.sh\ to automate the Bazel precommit environment, handling OpenSSL detection, Git HTTPS redirection, and dependency caching for reliable CI runs. Introduced \dev-with-k8s-db.sh\ to streamline local development by automatically port-forwarding to a Kubernetes CNPG database, extracting TLS certificates and application secrets (including Cloak keys) from cluster secrets, and launching the Phoenix server with the correct configuration.
elixir/web-ng/scripts · high confidence
New example configuration for declarative Ansible controller setup
Added a new Terraform example in \terraform/examples/configuration/main.tf\ that demonstrates how to declaratively configure a ServiceRadar Ansible controller. This example shows users how to define an AWX inventory reader credential, link an existing execution credential, and configure an Ansible controller with specific sync intervals for inventory and catalog, alongside an associated playbook repository.
terraform · high confidence
New local development loop for web-ng with Docker-backed database
Developers can now iterate on the web-ng UI and dashboard packages locally without rebuilding the release image. This change introduces a new skill that provides scripts to start the local Phoenix server against the Docker Compose CNPG database, automatically handling mTLS certificate copying, database password validation (with a repair option for mismatched secrets), and syncing plugin storage. It also includes a script to import and enable dashboard packages directly into the running Docker instance via RPC, along with Playwright commands for browser verification.
.agents/skills/web-ng-docker-loop · high confidence
New reproducible proof harness for the ServiceRadar anomaly engine
A new \tools/anomaly-proof\ directory provides a reproducible proof harness that runs the real Rust anomaly detector and disposition kernels over synthetic labeled data to measure precision, recall, and latency. It includes Python generators for edge metrics (CPU, memory, disk, SNMP counters) and core seasonal/capacity baselines, a real TimescaleDB end-to-end feed proof, and plotting/scoring scripts. Additionally, a Bazel wrapper script and a musl download mirror configuration are added to stabilize CI builds, and a Go utility is introduced to derive the agent release public key from a private signing key.
tools · high confidence
New utility modules for chart rendering, time formatting, and timezone handling
This change introduces a suite of new JavaScript utility modules in the web-ng frontend to improve chart accuracy, time display, and timezone support. The new \chart\_axis\_grid.js\ and \chart\_hover\_geometry.js\ modules provide precise calculations for chart axis ticks and hover interactions, ensuring correct mapping of mouse positions to data points even with asymmetric plot gutters. The \user\_time.js\ and \dashboard\_user\_time.js\ modules replace ad-hoc formatting with a robust system that respects user timezones, handles DST transitions, and preserves canonical timestamp precision for both dashboard displays and chart axes. Additionally, \timezone\_options.js\ adds logic to filter and search available timezones based on browser support, while \formatters.js\ standardizes the display of network flow metrics (bytes, bits, rates). Finally, \window\_events.js\ centralizes clipboard and file download handling, and \registerLiveReloadHelpers\ adds development conveniences for server log streaming and editor navigation.
elixir/web-ng/assets/js/utils · high confidence
SRQL service initialization and data model definitions
The SRQL service is now bootstrapped with a new configuration system that reads environment variables (prefixed with SRQL\_) and manages PostgreSQL connection pooling with explicit TLS certificate handling. The service exposes a comprehensive set of data models for querying fleet inventory (agents, devices, gateways), observability data (logs, traces, metrics), network events (BMP routing, OCSF events), and endpoint inventory (packages, scans), providing the foundational row structures for the query engine.
rust/srql · high confidence
ServiceRadar Core-ELX release environment and VM configuration
The ServiceRadar Core-ELX release now includes a new environment script (rel/env.sh.eex) and VM arguments file (rel/vm.args.eex) to configure the Erlang runtime. The environment script handles node naming, mTLS distribution settings, remote shell access, and cookie management. The VM arguments file sets performance tuning parameters, including capping schedulers to a 4-core cgroup quota, disabling busy-wait spin, and increasing process, port, and atom limits. It also enables kernel polling, configures cluster connectivity, and sets up crash dump logging.
_elixir/serviceradar\_core\elx/rel · high confidence
ServiceRadar anomaly core introduces seasonal, drift, and robust detection primitives
The \rust/anomaly-core\ crate now provides a comprehensive set of detection algorithms for per-series anomaly detection. It introduces a two-sided CUSUM drift detector (\cusum.rs\) to catch slow, sustained shifts that point z-scores miss, and Seasonal-Hybrid ESD primitives (\esd.rs\) using robust median/MAD to identify outliers while controlling family-wise error rates. A Robust PCA implementation (\rpca.rs\) via Principal Component Pursuit with Jacobi SVD is added for optional, heavyweight multivariate and seasonal pattern decomposition. The core detector (\detector.rs\) and its backtest harness (\anomaly-backtest.rs\, \scorecard.rs\) now support configurable seasonal baselines, dispersion floors (min std/CV), and saturation gates to prevent benign gauge values from triggering critical alerts, ensuring edge and central scoring parity.
rust/anomaly-core · high confidence
StarRocks warehouse schema and rollup definitions for telemetry data
This change introduces the StarRocks data warehouse schema for ServiceRadar, defining primary-key tables for network flows (OCSF), scalar metrics, logs, events, MTR traces/hops, OTel metrics/traces, and BMP routing events. It includes day-partitioned materialized views for hourly rollups of flows, metrics, events, and MTR hops to support dashboard performance, alongside specific tables for flow attribution observations. The schema ensures column parity with the existing CNPG backend and implements retention policies and sampling-weighted aggregations for accurate historical analysis.
_elixir/serviceradar\core/priv/starrocks · high confidence
Unified configuration schema and validation rule set
ServiceRadar introduces a centralized configuration schema (config.proto) and a data-driven validation rule set (rules.proto) to replace fragmented, language-specific checks. The schema defines environment kinds (including a new DEMO mode), database, NATS, and Dgraph connection details, and transport security settings, enforcing explicit presence and rejecting unspecified enum defaults to prevent silent misconfiguration. Validation logic is now declarative: rules specify predicates (such as Required, ForbiddenIf, and IntRange) and scopes, allowing constraints to be defined once and enforced across Go, Elixir, and other implementations via generated bindings and drift tests, ensuring consistency between committed instances and code.
config/proto · high confidence
Vendor Bumblebee scanner and Swift Arrow library under third\_party
This change consolidates vendored dependencies under the \//third\_party\ directory. It introduces the Bumblebee vulnerability scanner (v0.1.1) as a Go library, enabling in-process scanning of various package ecosystems (npm, Go, Python, browser extensions, etc.) without requiring external binaries. It also adds the Swift Arrow library with a local patch to \ArrowData.swift\ to safely handle omitted validity buffers, and exposes external binaries (nats\_server, crane) via \third\_party/binaries\.
_third\party · high confidence
Vendored Boombox audio/video streaming library added to third\_party
The \third\_party/hex\_vendored/boombox\ directory now contains the source code for the Boombox library, a tool for audio and video streaming built on the Membrane framework. This vendored copy includes the main application entry point, a Membrane Bin wrapper for pipeline integration, and internal components handling various input/output protocols such as HLS, RTMP, RTP, SRT, and WebRTC. Notably, this version is a ServiceRadar-specific build that removes SDL and PortAudio dependencies to allow headless builds, explicitly raising an error if the \:player\ output is requested.
(repo-wide) · high confidence
Behavioural changes
1 commit (0 fixes) modifying elixir/serviceradar\_nvr/config, elixir/serviceradar\_nvr/rel
A change to existing behaviour in elixir/serviceradar\_nvr/config, elixir/serviceradar\_nvr/rel — 1 commit, 3 files: “feat(nvr): package standalone recorder with retained per-replica storage”.
_elixir/serviceradar\_nvr/config, elixir/serviceradar\nvr/rel · low confidence · unverified
10 commits (0 fixes) modifying elixir/serviceradar\_recording
A change to existing behaviour in elixir/serviceradar\_recording — 10 commits, 16 files: “feat(nvr): recover initialization format from retained media”; “feat(nvr): discover retained sealed blocks after restart”; “feat(nvr): package standalone recorder with retained per-replica storage”; and 7 more.
_elixir/serviceradar\recording · medium confidence · unverified
10 commits (2 fixes) modifying config/manager\_config/rust/src/types
A change to existing behaviour in config/manager\_config/rust/src/types — 10 commits (2 fixs), 10 files: “Initialize ServiceRadar source”; “feat(config): complete stage 6 -- managers in three languages, explain, and rename”; “fix(config): resolve secrets from the environment, and stop carrying the CA”; and 7 more (refs \#5413).
_config/manager\config/rust/src/types · medium confidence · unverified
10 commits (3 fixes) modifying config/manager\_config/go
A change to existing behaviour in config/manager\_config/go — 10 commits (3 fixs), 9 files: “Initialize ServiceRadar source”; “feat(config): complete stage 6 -- managers in three languages, explain, and rename”; “fix(config): resolve secrets from the environment, and stop carrying the CA”; and 7 more (refs \#5413).
_config/manager\config/go · medium confidence · unverified
141 commits (47 fixes) modifying elixir/serviceradar\_core\_elx
A change to existing behaviour in elixir/serviceradar\_core\_elx — 141 commits (47 fixs), 61 files: “fix: retire standalone JetStream dependency”; “refactor(third\_party): consolidate vendored dependencies under //third\_party”; “fix(deps): align req on 0.7.3 across every project that embeds core”; and 137 more (refs \#2288, \#3027, \#6113, \#5774, \#3042, …).
_elixir/serviceradar\_core\elx · medium confidence · unverified
1837 commits (633 fixes) modifying go
A change to existing behaviour in go — 1837 commits (633 fixs), 2063 files: “feat(edge): publication-identity grammars — Nats-Msg-Id, Sr-Edge-Delivery-Id, Sr-Edge-Transport-Provenance as field-framed encoders (usp-v2-04)”; “fix(ci): unbreak bazel — netprobe zerolog dep + addon-sdk async-trait proc-macro (\#3425)”; “no-mistakes(test): Fix golangci findings and Elixir formatting”; and 1602 more (refs \#3425, \#2888, \#3873, \#459, \#3027, …).
go · medium confidence · unverified
19 commits (5 fixes) modifying rust/correlation-engine
A change to existing behaviour in rust/correlation-engine — 19 commits (5 fixs), 15 files: “Initialize ServiceRadar source”; “no-mistakes(review): redact connect errors, fix edge dedup, hop reads, demo backend”; “fix(topology): bound the remaining Dgraph reads under the gRPC receive limit”; and 16 more.
rust/correlation-engine · medium confidence · unverified
197 commits (69 fixes) modifying integration\_tests
A change to existing behaviour in integration\_tests — 197 commits (69 fixs), 34 files: “Deletes the SRQL\_FIXTURE\_ROOT override in the srql harness rather than relocating it. A value comes from the configuration system or from a declared build input; an ad-hoc environment override in a test can repoint an input to something the build graph does not know about, which is what makes a green result meaningless. Fixture data resolves through runfiles”; “test(edge\_record): restart embedded NATS after the cut probe so Groups D2, E and F run live (\#443)”; “no-mistakes(review): Redact actual release secrets from captured log tails”; and 136 more (refs \#443, \#456, \#391, \#459, \#450, …).
_integration\tests · medium confidence · unverified
23 commits (7 fixes) modifying rust/trapd
A change to existing behaviour in rust/trapd — 23 commits (7 fixs), 2 files: “fix: harden release checks and helm ha storage”; “Initialize ServiceRadar source”; “chore: update vulnerable dependencies”; and 18 more (refs \#12, \#5123, \#3097, \#4303, \#4302, …).
rust/trapd · medium confidence · unverified
3 commits (0 fixes) modifying docker/images/\_\_pycache\_\_
A change to existing behaviour in docker/images/\_\pycache\\_ — 3 commits, 1 file: “Initialize ServiceRadar source”; “cnpg + age + timescale”; “Chore/srql test failing (\#3036)” (refs \#3036).
docker/images/\\pycache\\_ · medium confidence · unverified_
30 commits (5 fixes) modifying elixir/serviceradar\_core/bench
A change to existing behaviour in elixir/serviceradar\_core/bench — 30 commits (5 fixs), 19 files: “fix eventwriter backpressure hotpath (\#3873)”; “Initialize ServiceRadar source”; “fix eventwriter backpressure hotpath”; and 25 more (refs \#3873, \#12).
_elixir/serviceradar\core/bench · medium confidence · unverified
3004 commits (570 fixes) modifying openspec
A change to existing behaviour in openspec — 3004 commits (570 fixs), 3724 files: “no-mistakes(review): Re-sign bumps, empty agent ids, and enabled leases”; “edge: mint and deliver per-agent nats.creds (B-5 sub-issue 1)”; “perf: avoid clearing desktop media headers”; and 2772 more (refs \#5328, \#5446, \#4111, \#3425, \#4144, …).
openspec · medium confidence · unverified
31 commits (1 fix) modifying elixir/serviceradar\_nvr
A change to existing behaviour in elixir/serviceradar\_nvr — 31 commits (1 fix), 20 files: “feat(nvr): share portable recording metadata contract”; “feat(nvr): recover initialization format from retained media”; “feat(nvr): reserve publication headroom before media admission”; and 28 more.
_elixir/serviceradar\nvr · medium confidence · unverified
35 commits (9 fixes) modifying rust/otel
A change to existing behaviour in rust/otel — 35 commits (9 fixs), 24 files: “Implement otel signal correlation: canonical IDs, summaries, trace detail UI”; “fix(otel): bound span-derived Prometheus labels and series”; “Initialize ServiceRadar source”; and 32 more (refs \#5112, \#5262, \#3796, \#2868).
rust/otel · medium confidence · unverified
36 commits (8 fixes) modifying elixir
A change to existing behaviour in elixir — 36 commits (8 fixs), 6 files: “refactor(third\_party): consolidate vendored dependencies under //third\_party”; “no-mistakes(document): Update stale BazelCI workflow and web-ng lane references”; “Initialize ServiceRadar source”; and 33 more (refs \#5165, \#3035, \#3040, \#5291, \#356).
elixir · medium confidence · unverified
3877 commits (1630 fixes) modifying elixir/serviceradar\_core
A change to existing behaviour in elixir/serviceradar\_core — 3877 commits (1630 fixs), 1990 files: “fix: retire standalone JetStream dependency”; “feat(edge): publication-identity grammars — Nats-Msg-Id, Sr-Edge-Delivery-Id, Sr-Edge-Transport-Provenance as field-framed encoders (usp-v2-04)”; “no-mistakes(document): Format routing files; docs already current”; and 3537 more (refs \#2888, \#5328, \#4705, \#323, \#379, …).
_elixir/serviceradar\core · medium confidence · unverified
394 commits (171 fixes) modifying elixir/serviceradar\_agent\_gateway
A change to existing behaviour in elixir/serviceradar\_agent\_gateway — 394 commits (171 fixs), 54 files: “fix: retire standalone JetStream dependency”; “fix(lint): repair the Elixir gate breakage that \#4705 landed”; “refactor(third\_party): consolidate vendored dependencies under //third\_party”; and 315 more (refs \#4705, \#3103, \#2288, \#459, \#2691, …).
_elixir/serviceradar\_agent\gateway · medium confidence · unverified
4 commits (0 fixes) modifying elixir/serviceradar\_recording\_metadata
A change to existing behaviour in elixir/serviceradar\_recording\_metadata — 4 commits, 11 files: “no-mistakes(document): Document LocalPublicationIntent in recording metadata README”; “feat(nvr): share portable recording metadata contract”; “feat(nvr): acknowledge local intents against frozen Core authority”; and 1 more.
_elixir/serviceradar\_recording\metadata · medium confidence · unverified
4 commits (1 fix) modifying elixir/serviceradar\_srql/native/srql\_nif/schemas
A change to existing behaviour in elixir/serviceradar\_srql/native/srql\_nif/schemas — 4 commits (1 fix), 2 files: “Initialize ServiceRadar source”; “fix(srql\_nif): align capnp codegen with capnp 0.25”; “feat: use arancini (\#2855)”; and 1 more (refs \#2855).
_elixir/serviceradar\_srql/native/srql\nif/schemas · medium confidence · unverified
40 commits (3 fixes) modifying github.com/carverauto/serviceradar
A change to existing behaviour in github.com/carverauto/serviceradar — 40 commits (3 fixs), 8 files: “spec(edge): freeze the compiled-carrier grammars; Elixir peers + parity vectors”; “Persist validated attribution and relocation commit evidence”; “Initialize ServiceRadar source”; and 22 more (refs \#12, \#460, \#5413, \#2868, \#4145).
github.com/carverauto/serviceradar · medium confidence · unverified
44 commits (12 fixes) modifying js/cli
A change to existing behaviour in js/cli — 44 commits (12 fixs), 45 files: “Initialize ServiceRadar source”; “no-mistakes(document): Document CLI 0.1.10 release”; “feat(cli): add --bundle flag to plugin publish for Bazel zip artifacts”; and 41 more (refs \#4147, \#5413, \#5306).
js/cli · medium confidence · unverified
466 commits (77 fixes) modifying proto
A change to existing behaviour in proto — 466 commits (77 fixs), 725 files: “feat(edge): publication-identity grammars — Nats-Msg-Id, Sr-Edge-Delivery-Id, Sr-Edge-Transport-Provenance as field-framed encoders (usp-v2-04)”; “sync before linting”; “cleanup”; and 316 more (refs \#459, \#2691, \#2667, \#2279, \#12, …).
proto · medium confidence · unverified
5 commits (1 fix) modifying config/manager\_secret
A change to existing behaviour in config/manager\_secret — 5 commits (1 fix), 26 files: “Initialize ServiceRadar source”; “feat(config): complete stage 6 -- managers in three languages, explain, and rename”; “fix(config): resolve secrets from the environment, and stop carrying the CA”; and 2 more.
_config/manager\secret · medium confidence · unverified
6 commits (0 fixes) modifying config/manager\_config/elixir
A change to existing behaviour in config/manager\_config/elixir — 6 commits, 8 files: “Initialize ServiceRadar source”; “feat(config): complete stage 6 -- managers in three languages, explain, and rename”; “feat(dgraph): obtain a Dgraph for tests wherever the test runs”; and 3 more.
_config/manager\config/elixir · medium confidence · unverified
6 commits (0 fixes) modifying rust/cert-policy
A change to existing behaviour in rust/cert-policy — 6 commits, 4 files: “no-mistakes(review): Correct install docs, DNS comment, and format”; “Enforce managed certificate policy for Rust NATS collectors”; “no-mistakes(review): Restore NATS publishing after renewed policy”; and 3 more.
rust/cert-policy · medium confidence · unverified
6 commits (1 fix) modifying build/elixir\_quality
A change to existing behaviour in build/elixir\_quality — 6 commits (1 fix), 4 files: “feat(nvr): share portable recording metadata contract”; “build(camera): use existing Bazel quality gates for recording library”; “feat(nvr): package standalone recorder with retained per-replica storage”; and 3 more.
_build/elixir\quality · medium confidence · unverified
6 commits (2 fixes) modifying config/manager\_config/elixir/priv
A change to existing behaviour in config/manager\_config/elixir/priv — 6 commits (2 fixs), 1 file: “Initialize ServiceRadar source”; “fix(config): resolve secrets from the environment, and stop carrying the CA”; “fix(ci): fetch fixture CA bundles over LAN HTTPS”; and 3 more (refs \#5413).
_config/manager\config/elixir/priv · medium confidence · unverified
7 commits (2 fixes) modifying docker/compose/profiles
A change to existing behaviour in docker/compose/profiles — 7 commits (2 fixs), 3 files: “fix(nats): raise small profile max\_file\_store from 30G to 36G”; “no-mistakes(document): Budget the exposure dimension stream”; “no-mistakes(review): Step edge cutover drain via timer; align Compose edge sizes”; and 4 more.
docker/compose/profiles · medium confidence · unverified
Centralized configuration management with embedded validation rules
The Rust configuration crate now provides a unified system for resolving environment-specific settings, including dedicated modules for fetching CA bundles, managing secret names (such as database and Dgraph credentials), and enforcing a committed rule set embedded directly in the binary. This change ensures that configuration instances are validated against trusted, build-time rules rather than untrusted mounted files, and it centralizes the definition of secret identifiers so that multiple components can consistently resolve the same credentials without duplicating logic or introducing circular dependencies.
_config/manager\config/rust/src · high confidence
Enforce Elixir formatting locally and add pre-push secret scanning
The repository now includes local git hooks to improve code quality and security before commits and pushes. The new \mix-format-elixir\ hook formats staged Elixir files and checks for unformatted code in sibling projects, failing the commit if issues are found (replacing the previous behavior where unformatted code was silently skipped locally). A \pre-commit\ hook now runs \pre-commit\ checks and specific quick checks for the \god\_view\ component. Additionally, a \pre-push\ hook integrates \gitleaks\ to scan for secrets in pushed commits, providing local feedback before pushing to the remote where Forgejo Actions also enforces secret scanning.
.githooks · high confidence
Enforced validation rules for plugin and add-on assignments, profiles, and packages
The ServiceRadar control plane now applies strict validation rules at write time for plugin and add-on configurations, preventing invalid or conflicting states from reaching agents. Assignment parameters are validated against package config schemas before persistence, with specific handling for policy-owned envelopes and credential references. Duplicate enabled assignments for the same agent and plugin/add-on are rejected, as are manual assignments that shadow policy-owned ones. Add-on profiles are restricted to target only the 'agents' entity, and duplicate target queries for the same add-on are blocked. Exclusive add-ons (like 'anomaly') allow only one enabled profile. Package references must point to approved packages, and repository credentials must be API tokens with valid ed25519 signing keys. Deletions of assignments or profiles are blocked if active rollouts depend on them, ensuring rollout integrity.
_elixir/serviceradar\core/lib/serviceradar/plugins/validations · high confidence
Introduce unified, file-based environment configuration for ServiceRadar
ServiceRadar now uses a centralized configuration schema defined in \config/environments\ to manage deployment settings for CI, localhost, SaaS, and demo environments. These \.textproto\ files replace the previous reliance on ambient process environment variables, allowing consumers to declare specific environment instances as build dependencies. This change ensures that configuration is a declared input, improves security by excluding secrets from version control (resolved via SecretManager at runtime), and standardizes connection details for databases, NATS, core services, and Dgraph across all supported environments.
config/environments · high confidence
Migrate build system from Mix to Bazel
The Elixir build process has been migrated from the standard Mix toolchain to Bazel. This change enables hermetic compilation, consistent remote execution, and improved build performance across development and CI environments.
(repo-wide) · high confidence
Migrate web-ng asset build to Bazel and pin deck.gl/luma.gl versions
The web-ng assets build has been moved from the Elixir release action to a dedicated Bazel package, replacing the previous \bun install\ and \mix\-based pipeline with Bazel-managed \npm\_link\_all\_packages\ and explicit \js\_library\/\js\_test\ targets. This change improves build caching by decoupling JavaScript tooling from Elixir source changes. Additionally, the JavaScript dependency graph has been updated to align deck.gl and luma.gl to version 9.4.x (with specific overrides for deck.gl 9.4.0 and luma.gl 9.4.2) to resolve symbol mismatches, and the LiveView client has been pinned to version 1.2.9 to match the server-side Hex package.
elixir/web-ng/assets · high confidence
Migrate web-ng settings to a structured 3-category, 2-level navigation tree
The Settings interface has been reorganized into a structured navigation tree with three main categories and two levels of hierarchy, replacing the previous flat or legacy layout. This change includes migrating the remaining settings pages to the new catalog, updating contextual and suppressed status cards, and removing unused legacy navigation components to streamline access to configuration options.
elixir/web-ng · high confidence
NetFlow charts now localize time labels to user timezone and improve axis readability
The NetFlow page now displays time labels on axes and tooltips according to the user's selected timezone instead of forcing UTC, while still preserving the canonical UTC instant for accessibility and data integrity. Additionally, the chart axes now intelligently switch their label format based on the time range: showing clock time for single-day views, adding dates for multi-day views, and showing full dates for longer periods to prevent label ambiguity. These changes are implemented in the new \netflow\_charts/util.js\ module, which handles timezone formatting, axis styling logic, and tooltip geometry.
_elixir/web-ng/assets/js/netflow\charts · high confidence
New Rust-based integration database lifecycle and connection observer
The integration database lifecycle has been rewritten in Rust to replace shell scripts and reduce CI startup overhead. New binaries manage the shared schema template (\prepare\_template\, \reset\_template\), provision per-run databases (\provision\_base\), and handle immutable schema generations (\generation\). A new connection observer (\observe\_connections\) monitors PostgreSQL connection capacity and quiescence during tests. Configuration is now resolved via a unified ConfigManager and SecretManager, eliminating fragile DSN parsing and hand-rolled runfile lookups.
rust/integration-db · high confidence
Port capacity forecasting kernel to Rust with improved prediction intervals
The capacity forecasting logic in the \anomaly-disposition\ crate has been rewritten in Rust, porting the Elixir \ServiceRadar.Observability.CapacityForecasting.Model\ to provide linear and Holt-Winters seasonal forecasts. This change introduces a new \disposition-backtest\ tool for replaying synthetic data through the core disposition kernels without a database. The forecasting engine now uses closed-form OLS prediction intervals for linear models and residual-bootstrap intervals for Holt-Winters, replacing the previous constant ±1.96·RMSE band. It also adds robust slope significance testing via the Theil-Sen estimator to skip forecasts where trends are not statistically significant, and improves exhaustion ETA reporting by distinguishing between history-capped and raw crossings.
rust/anomaly-disposition · high confidence
ServiceRadar brand theme and CSS architecture overhaul
The web application's visual identity has been updated to the ServiceRadar brand, replacing the previous Nocturne cyan/blue color scheme with a marketing-aligned green palette in both light and dark modes. This change introduces a new set of design tokens (e.g., \--color-sr-\*\) and removes the daisyUI plugin in favor of custom Tailwind brand primitives, ensuring consistent styling across components like the SRQL input and dashboard maps.
elixir/web-ng/assets/css · high confidence
Unified log collector merges Flowgger and OTEL pipelines
The log-collector service has been refactored to combine the previously separate Flowgger (syslog/GELF) and OpenTelemetry (OTLP) ingestion pipelines into a single binary. Users now configure both pipelines via a unified TOML config file, with each pipeline independently enabled or disabled and pointing to its own native configuration file (defaulting to /etc/serviceradar/flowgger.toml and /etc/serviceradar/otel.toml). A unified gRPC health check server is now exposed on port 50044, reporting the status of the log-collector, flowgger, and otel services individually. The binary also switches the rustls TLS provider from aws-lc-rs to ring and includes a self-telemetry CPU storm reduction by adjusting log levels, the OTel root sampler, and the self-telemetry denylist.
rust/log-collector · medium confidence
Updated vendored ServiceRadar SDK to v2
The demo vendor directory now includes the released v2 tag of the \serviceradar-sdk-go\ library, replacing the previous local copy. This update brings new SDK capabilities including structured action descriptors, advisory feed batches, artifact streaming, and camera plugin support, ensuring the demo uses the official, stable SDK version.
demo/vendor · high confidence
Fixes
1 commit (1 fix) fixing third\_party/rust\_patches/tonic-0.14.6
A fix in third\_party/rust\_patches/tonic-0.14.6 — 1 commit (1 fix), 60 files: “fix(deps): patch tonic onto zstd 0.14.3 for the zstd RustSec advisories”.
_third\_party/rust\patches/tonic-0.14.6 · medium confidence · unverified
5 commits (3 fixes) fixing elixir/serviceradar\_recording\_control
A fix in elixir/serviceradar\_recording\_control — 5 commits (3 fixs), 5 files: “fix(nvr): gate upload lease acquisition and renewal on recovery”; “fix(nvr): gate archive publication and playback on recovery”; “no-mistakes(document): Document recovery-gate test owners for new-work admission”; and 2 more.
_elixir/serviceradar\_recording\control · medium confidence · unverified
Add local test SDK stubs for WASM plugin builds
A new test-only Go library has been added to the build system to provide compile-time stubs for the ServiceRadar SDK. This includes definitions for signal schema references, telemetry records, and logging interfaces, allowing WASM plugin components (such as Axis, Proxmox, and UniFi Protect) to build against a consistent, minimal surface without requiring the full external SDK during compilation.
_build/wasm\plugins/testsdk · high confidence
Added TinyGo reflection compatibility probe
A new test tool, \tinygo\_reflection\_probe\, has been added to verify that the TinyGo compiler correctly handles reflection checks for \json.Marshaler\ and \errors.As\ interfaces. This probe ensures that plugins relying on these standard library features function correctly, addressing potential panics in older TinyGo versions.
_build/wasm\plugins/testdata · high confidence
Fix God View WASM loading in production builds
The God View feature now correctly loads its WebAssembly module in production environments. Previously, the code relied on \import.meta.url\ to locate the \.wasm\ asset, which fails in the production IIFE bundle because \import.meta.url\ is empty, causing the topology view to hang on a loading state. This change introduces a dedicated runtime (\GodViewWasmEngine\) that fetches the WASM file from a static Phoenix asset path (\/assets/js/god\_view\_exec.wasm\) and includes logic to retry with fallback paths, ensuring the visualization loads reliably.
elixir/web-ng/assets/js/wasm · high confidence
Fix WebGPU picking coordinates and compute binding isolation in deck.gl and luma.gl
Applied patches to deck.gl 9.4 and luma.gl 9.4.2 to resolve WebGPU-specific rendering issues. The deck.gl patch corrects asynchronous picking coordinate boundaries by converting bottom-left picking queries to top-left WebGPU coordinates, ensuring node clicks, edge picks, and rectangle picks register at the correct visible positions. The luma.gl patch isolates mutable binding dictionaries for each WebGPU compute pipeline, preventing shared-state regressions in compute operations.
elixir/web-ng/assets/patches · high confidence
Initialize ServiceRadar schema baseline for fresh database installs
Added a frozen schema baseline (platform\_schema.sql) and its metadata (metadata.json) for the ServiceRadar core module, generated from a replayed empty database on PostgreSQL 18. This ensures that fresh installations start with a consistent, checksummed schema state, preventing bootstrap failures caused by schema drift or missing baseline files.
_elixir/serviceradar\core/priv/repo/baseline · high confidence
Test coverage
10 commits adding/updating tests in build/media; 104 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/credentials; 11 commits adding/updating tests in elixir/serviceradar\_core/test/release\_gates; 115 commits adding/updating tests in elixir/serviceradar\_core/test/integration; 140 commits adding/updating tests in build/contracts; 143 commits adding/updating tests in elixir/serviceradar\_core/test/support; 16 commits adding/updating tests in elixir/web-ng/test/phoenix/live/security; 17 commits adding/updating tests in elixir/serviceradar\_core\_elx/test/serviceradar\_core\_elx/camera\_recording; 197 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/event\_writer; 2 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/ingestion; 20 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/agent\_config/compilers; 220 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/sweep\_jobs; 234 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/event\_writer/processors; 25 commits adding/updating tests in elixir/web-ng/test/serviceradar\_web\_ng\_web/live/settings; 26 commits adding/updating tests in elixir/serviceradar\_nvr/test; 282 commits adding/updating tests in elixir/serviceradar\_agent\_gateway/test/serviceradar\_agent\_gateway; 3 commits adding/updating tests in elixir/web-ng/test/serviceradar\_web\_ng/edge; 35 commits adding/updating tests in elixir/serviceradar\_core\_elx/test/serviceradar\_core\_elx/camera\_relay; 46 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/camera; 477 commits adding/updating tests in elixir/serviceradar\_core/test; 48 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/cluster; 5 commits adding/updating tests in config/manager\_config/elixir/test; 51 commits adding/updating tests in elixir/web-ng/test/integration; 6 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/inventory/availability; 6 commits adding/updating tests in elixir/serviceradar\_core\_elx/test/fixtures; 7 commits adding/updating tests in elixir/serviceradar\_core\_elx/test/support; 709 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/edge; 79 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/nats; 8 commits adding/updating tests in config/manager\_config/rust/tests; 85 commits adding/updating tests in elixir/serviceradar\_core\_elx/test/serviceradar\_core\_elx; 95 commits adding/updating tests in elixir/serviceradar\_core/test/serviceradar/proto; Add conformance fixtures for ServiceRadar configuration rules; Add tests for database fixture configuration and schema template generation; Added ExUnit tests for camera relay analysis and media ingress; Added admin UI tests for add-on fleet, packages, collectors, dashboards, and plugins; Added comprehensive test coverage for Armis Northbound integration and composite value exports; Added comprehensive test coverage for advisory feed ingestion and configuration; Added comprehensive test coverage for the automation callback grants subsystem; Added contract tests for Phoenix helper modules; Added controller integration tests for web-ng authentication and dashboard APIs; Added golden file comparison and diff utilities for DIRE trace tests; Added hosted bitmap scale acceptance test harness; Added integration and unit tests for the Northbound automation subsystem; Added integration test for God-view device page hydration; Added integration tests for CLI device authorization cleanup worker; Added integration tests for MTR reader parity between CNPG and StarRocks; Added integration tests for ScanRun lifecycle and NATS-backed AdhocScan ingestion; Added integration tests for ServiceRadar gateway registration; Added live integration tests for Armis Northbound sync and StarRocks flow attribution correlation; Added native benchmark fixtures for bitmap index and view projection performance; Added property-based tests for API and LiveView stability; Added regression tests for API credentials and user settings LiveViews; Added regression tests for Swift Arrow package compilation; Added regression tests for schema migration ledger exclusion; Added router contract tests for authentication and SAML routing; Added shared test fixtures for configuration validation; Added test coverage for Agent Live views; Added test coverage for Ansible AWX automation components; Added test coverage for SNMP profile credential resolution, targeting, and lifecycle management; Added test coverage for ServiceRadar Edge onboarding and bundle generation; Added test coverage for ServiceRadar Identity and Infrastructure resources; Added test coverage for ServiceRadar NATS components; Added test coverage for ServiceRadar Web-NG dashboard and telemetry components; Added test coverage for ServiceRadar background job workers; Added test coverage for ServiceRadar infrastructure components; Added test coverage for ServiceRadar monitoring and onboarding triggers; Added test coverage for alert device identity and notification wiring; Added test coverage for dashboard, topology, and remote-access Phoenix channels; Added test coverage for edge provision and event workers; Added test coverage for identity reconciliation and address classification; Added test coverage for inventory remediation steps; Added test coverage for inventory sync policies and execution; Added test coverage for network config ingestion and processing; Added test coverage for network discovery mapper and topology ingestion; Added test coverage for notification action links, token redemption, and delivery retention; Added test coverage for observability subsystem components; Added test coverage for remote access LiveViews; Added test coverage for security audit history, event recording, and rate limiting; Added test coverage for the SeasonalDisposition subsystem; Added test coverage for the ServiceRadar dashboard LiveView; Added test coverage for the Settings navigation catalog and notification settings UI; Added test coverage for the cold-tier telemetry offload system; Added test coverage for the new prefix tags subsystem; Added test coverage for topology graph canonical rebuild and mutation logic; Added test coverage for web-ng Phoenix plugs; Added test coverage for web-ng authentication components; Added test fixtures for accounts, notifications, and SAML authentication; Added test fixtures for timestamp formatter inventory and million-device topology encoding; Added test helper to ensure telemetry application starts before tests; Added test support infrastructure for web-ng; Added tests for Admin API parameter validation, user lifecycle, and path encoding; Added tests for AgentConfig compiler, invalidation, and dependency catalog; Added tests for AgentRegistry functionality; Added tests for AlienVault OTX provider sync; Added tests for DataService client channel management; Added tests for Device and SystemActor modules; Added tests for EgressClient and EgressProxy HTTP transport; Added tests for Event LiveView timezone localization, device linking, and alert rule creation; Added tests for IOC flow filtering logic; Added tests for MCP OAuth IDP session refresh logic; Added tests for MTR diagnostics live components; Added tests for NetFlow Live visualization filters and flow list state handling; Added tests for Netflow Visualize query logic and state management; Added tests for OIDC client retry logic; Added tests for OTel gRPC channel lifecycle and log exporter sanitization; Added tests for OTel log filtering and context propagation; Added tests for PluginConfigForm component behavior; Added tests for PostgreSQL schema SQL parsing and extension privilege handling; Added tests for RBAC Live View components and state management; Added tests for RBAC catalog permissions; Added tests for RepoClient egress routing and GitHub rate-limit handling; Added tests for SNMP profile lifecycle, provenance, and targeting; Added tests for SRQL builder, catalog, and scope builder logic; Added tests for SRQL query builder, access control, and parity validation; Added tests for ServiceRadar Edge OnboardingPackage lifecycle; Added tests for ServiceRadar Inventory Device resource; Added tests for ServiceRadar SRQL native encoding; Added tests for ServiceRadar automation callback contracts and security foundations; Added tests for ServiceRadar core event handling and publishing; Added tests for ServiceRadar notification firehose replay logic; Added tests for ServiceRadar observability contract and state logic; Added tests for ServiceRadar service port lookup and labeling; Added tests for StarRocks analytics components; Added tests for Sysmon profile sample interval parsing and compiler logic; Added tests for WebSocket transport compression and concurrency; Added tests for WiFi Map batch ingestor and CSV seed payload parsing; Added tests for Zen normalizer caching and SNMP trap normalization; Added tests for admin user bootstrap and password synchronization logic; Added tests for agent command status handling and pubsub gating; Added tests for alert detail page authorization and controls; Added tests for anomaly detection series key generation and alignment; Added tests for attributed flow row mapping and time-window navigation; Added tests for authorization permissions; Added tests for camera relay, FieldSurvey Arrow, and notification firehose channels; Added tests for composite check catalog filtering logic; Added tests for composite check inputs, rules, evaluation, and device merge handling; Added tests for composite check rules, sweep context, and agent picker components; Added tests for composite check validation coverage and orchestration; Added tests for credential coverage and native add-on sync decisions; Added tests for dashboard package access controls, action confirmations, and UI behavior; Added tests for dashboard package manifest validation and import logic; Added tests for device endpoint inventory findings logic; Added tests for device live view components; Added tests for discovery decoders and ingestor parity with Go translators; Added tests for flow attribution correlation, observations, and metrics; Added tests for identity diagnostics and SRQL binding safety; Added tests for identity validation logic; Added tests for launch envelope encryption, resolution, and security constraints; Added tests for manual device creation and classification protection; Added tests for metric detail trace pivots and timestamp localization; Added tests for migration ledger synchronization and JSONB parameter safety; Added tests for network address and outbound URL policies; Added tests for notification callback body buffering and size limits; Added tests for notification callback verification and key management; Added tests for object store retention logic; Added tests for observability event-device linking and service filter handling; Added tests for outbound mail runtime configuration and SMTP TLS handling; Added tests for plugin and add-on management logic; Added tests for stale job reaping and trace summary refresh workers; Added tests for the Anomaly Disposition Peak Profile module; Added tests for the Attributed Flows LiveView; Added tests for the DirectTelemetryWrite Credo check; Added tests for the ServiceRadar dashboard frame runner; Added tests for the declarative notification provider catalog and definition validator; Added tests for the new notification transport layer; Added tests for the stateful alert engine lifecycle and rule matching; Added tests for the trace detail view (TraceLive.Show); Added tests for threat intel page model and STIX indicator normalization; Added tests for topology domain logic and data contracts; Added tests to prevent product artifacts from referencing the demo tree; Added unit tests for NetFlow enrichment expiry SQL generation; Added unit tests for Netflow Live chart states, interface traffic, and local anchors; Added unit tests for ServiceRadar Web-NG components; Added unit tests for ServiceRadar infrastructure resources; Added unit tests for composite export validation; Added unit tests for dashboard access control logic; Added unit tests for the shared WebRTC ICE credential provider; Added unit tests for web-ng Phoenix components; Added unit tests for web-ng domain logic; Expanded test coverage for LogLive observability features; Expanded test coverage for ServiceRadar core ingestion and infrastructure; Expanded test coverage for Settings LiveViews; Expanded test coverage for dashboard authoring, serialization, and access control; Expanded test coverage for dashboard, remote access, and SSH console components; Expanded test coverage for identity subsystem components; Expanded test coverage for inventory subsystems; Expanded test coverage for topology bitmap queries, Atlas control, and native index operations; Expanded test coverage for web-ng LiveView components and helpers; Expanded test coverage for web-ng Phoenix components; New Playwright acceptance tests for visibility profiles, dashboard authoring, and UI layout; New database-backed test lanes for MTR reader parity, topology atlas, and network live views; New deterministic parity test harness for StarRocks and CNPG backends; Test coverage for web-ng Phoenix plugs; Test infrastructure overhaul: DB-free execution, zero-test detection, and OCSF schema support; Tests for addon assignment deduplication, uniqueness, and rollout coordination.
Dependencies
Rust workspace migration to Edition 2024 and consolidated dependency management
The Rust build system has been upgraded to Edition 2024, requiring a minimum Rust version of 1.97.1, and all workspace dependencies are now centrally defined in the root \Cargo.toml\ to reduce redundancy. This change introduces a new \Cargo.lock\ file to track resolved versions and updates key libraries, including \axum\ to 0.8, \tonic\ and \prost\ to 0.14, and \diesel\ to 2.3, while also switching the TLS provider from \aws-lc-rs\ to \ring\ for improved hermeticity.
(dependencies) · high confidence
Vendored addr2line and dlmalloc dependencies added to third\_party
The repository now includes vendored copies of the \addr2line\ Rust library and the \dlmalloc\ memory allocator under \third\_party/netprobe\_ebpf\_vendor\. The \addr2line\ component provides a cross-platform library for retrieving per-address debug information (file name, line number, function name) from DWARF debug sections, including support for split DWARF, inline call stacks, and symbol table lookups via a \Loader\ API. The \dlmalloc\ component provides a Rust port of the Doug Lea malloc implementation for memory management. These additions support the underlying eBPF toolchain's need for address translation and memory allocation capabilities.
(repo-wide) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 56 → 59 (+2.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 54 → 56 (+1.4)
- Architecture 82 → 81 (-1.2)
- Maturity 87 → 95 (+8.0)
- Readiness 55 → 53 (-2.5)
- Security 68 → 69 (+1.3)
- Domain Modelling 100 → 100 (+0.0)
- Event-Driven 100 (new)
- Event Sourcing 100 → 100 (+0.0)
- Accessibility 50 → 58 (+7.6)
- Performance 88 → 100 (+11.6)
Resolved (433)
- Boundary-crossing change coupling: config.go ↔ config.rs (go/pkg/agent/netprobe/config.go)
- Change coupling: attribution.rs ↔ config.rs (rust/netprobe/src/attribution.rs)
- Change coupling: lifecycle_dom_interaction_methods.js ↔ lifecycle_dom_setup_methods.js (elixir/web-ng/assets/js/lib/god_view/lifecycle_dom_interaction_methods.js)
- Checkable ADR rule enforced only by prose: Architecture Decision Record: Adopt a Portable Operational Ontology as the Semantic Integration Boundary (docs/learnings/adr/2026-08-16-portable-operational-ontology-engine.md)
- Config::validate (cognitive 17) (rust/rperf-client/src/config.rs)
- Duplicated block (10 lines × 2) (elixir/serviceradar_core/lib/serviceradar/admission/flow_lane.ex)
- Duplicated block (10 lines × 2) (elixir/serviceradar_core/lib/serviceradar/event_writer/processors/falco_events.ex)
- Duplicated block (10 lines × 2) (elixir/serviceradar_core/lib/serviceradar/graph.ex)
- Duplicated block (10 lines × 2) (elixir/serviceradar_core/lib/serviceradar/integrations/armis_northbound_runner.ex)
- Duplicated block (10 lines × 2) (elixir/web-ng/lib/serviceradar_web_ng_web/live/device_live/index_view/badges.ex)
- Duplicated block (10 lines × 2) (elixir/web-ng/lib/serviceradar_web_ng_web/live/gateway_live/show.ex)
- Duplicated block (10 lines × 2) (elixir/web-ng/lib/serviceradar_web_ng_web/live/log_live/index.ex)
- Duplicated block (10 lines × 2) (rust/flow-collector/src/publisher.rs)
- Duplicated block (10 lines × 2) (rust/srql/src/query/advisory.rs)
- Duplicated block (10 lines × 2) (rust/srql/src/query/endpoint_inventory_scans.rs)
- Duplicated block (10 lines × 2) (rust/srql/src/query/endpoint_packages.rs)
- Duplicated block (10 lines × 2) (rust/srql/src/query/mtr_hops.rs)
- Duplicated block (10–11 lines × 2) (elixir/serviceradar_agent_gateway/lib/serviceradar_agent_gateway/agent_gateway_server.ex)
- Duplicated block (10–11 lines × 2) (rust/srql/src/query/logs/topn.rs)
- Duplicated block (10–12 lines × 2) (elixir/web-ng/lib/serviceradar_web_ng_web/live/diagnostics_live/mtr_data.ex)
- …and 413 more
New (4284)
- (anonymous) (cognitive 16) (elixir/web-ng/assets/camera_archive_player.playwright.js)
- (anonymous) (cognitive 18) (elixir/web-ng/assets/camera_archive_player.playwright.js)
- (anonymous) (cognitive 23) (elixir/web-ng/assets/camera_codec_capability.playwright.js)
- (anonymous) (cyclomatic 16) (elixir/web-ng/assets/camera_archive_player.playwright.js)
- (anonymous) (cyclomatic 19) (elixir/web-ng/assets/camera_codec_capability.playwright.js)
- Allocator.resumeRecovery (cognitive 18) (go/pkg/edge/spool/reserve_resume.go)
- AnalyticsSignals.do_process_batch (cognitive 35) (elixir/serviceradar_core/lib/serviceradar/event_writer/processors/analytics_signals.ex)
- ArchiveAuthorities.do_apply (cognitive 24) (elixir/serviceradar_core/lib/serviceradar/camera/archive_authorities.ex)
- ArchiveAuthorities.do_revoke (cognitive 25) (elixir/serviceradar_core/lib/serviceradar/camera/archive_authorities.ex)
- ArchiveAuthorities.do_with_current (cognitive 16) (elixir/serviceradar_core/lib/serviceradar/camera/archive_authorities.ex)
- ArchiveAuthorities.do_with_current (cyclomatic 16) (elixir/serviceradar_core/lib/serviceradar/camera/archive_authorities.ex)
- ArchiveStorageListener.load! (cognitive 18) (elixir/web-ng/lib/serviceradar_web_ng/archive_storage_listener.ex)
- ArchiveStorageListener.load! (cyclomatic 18) (elixir/web-ng/lib/serviceradar_web_ng/archive_storage_listener.ex)
- ArchiveUploads.archive_inventory (cognitive 18) (elixir/serviceradar_core/lib/serviceradar/camera/archive_uploads.ex)
- ArchiveUploads.archive_metadata (cognitive 18) (elixir/serviceradar_core/lib/serviceradar/camera/archive_uploads.ex)
- AssignmentValidate.validate_identity (cognitive 17) (elixir/serviceradar_core/lib/serviceradar/edge/assignment_validate.ex)
- AssignmentValidate.validate_identity (cyclomatic 17) (elixir/serviceradar_core/lib/serviceradar/edge/assignment_validate.ex)
- BGPSimulationConfig.UnmarshalJSON (cognitive 19) (go/cmd/faker/main.go)
- BGPSimulationConfig.UnmarshalJSON (cyclomatic 19) (go/cmd/faker/main.go)
- Boundary-crossing change coupling: contract_catalog.ex ↔ push_loop.go (elixir/serviceradar_core/lib/serviceradar/edge/contract_catalog.ex)
- …and 4264 more
Changes since last survey
- 300 commits — 197 feature/other, 103 fixes
By area
- elixir/serviceradar_core — 107 commits
- (repo) — 81 commits
- elixir/web-ng — 25 commits
- openspec/changes — 25 commits
- docs/docs — 11 commits
- elixir/serviceradar_nvr — 11 commits
- elixir/serviceradar_agent_gateway — 7 commits
- helm/serviceradar — 5 commits
- (root) — 3 commits
- docs/awx-proxmox-unmerge-runbook.md — 3 commits
- go/pkg — 3 commits
- build/release — 2 commits
- docs/nvr-runtime.md — 2 commits
- elixir/serviceradar_recording_control — 2 commits
- k8s/starrocks — 2 commits
- rust/dgraph-topology — 2 commits
- scripts/cosign_common.sh — 2 commits
- build/contracts — 1 commit
- build/logger_metadata_contract_test.exs — 1 commit
- docs/edge-record-dead-letter-runbook.md — 1 commit
Notable commits
- fix: Merge branch 'staging' into fix/snmp-compile-batched-lookups
- fix: Merge pull request #6485 from carverauto/fix/device-events-oom-6465
- fix: Merge pull request #6490 from carverauto/fix/revert-edge-stream-discard-6471
- fix: Merge pull request #6492 from carverauto/fix/publish-oci-idempotent-signing
- fix: Merge pull request #6494 from carverauto/fix/starrocks-pod-antiaffinity-labels
- fix: Merge pull request #6497 from carverauto/fix/large-ingestion-gate-recovery-coverage
- fix: Merge pull request #6498 from carverauto/fix/cross-node-rolling-upgrade-rpc
- fix: Merge pull request #6500 from carverauto/fix/cross-node-rolling-upgrade-rpc
- fix: Merge pull request #6503 from carverauto/fix/web-ng-jsonapi-accept-media-type
- fix: Merge pull request #6504 from carverauto/fix/sweep-lease-refresh-timeout
- fix: Merge pull request #6505 from carverauto/fix/schedule-wedge-and-stale-awx
- fix: Merge pull request #6508 from carverauto/fix/issue-6428-default-edge-spool-dlq-alerts
- fix: Merge pull request #6513 from carverauto/fix/addon-rollout-reclassify-targets
- fix: Merge pull request #6515 from carverauto/fix/eventwriter-startup-consumer-ready
- fix: Merge pull request #6518 from carverauto/fix/starrocks-stream-load-first-attempt-timeout
- fix: Merge pull request #6519 from carverauto/fix/disabled-assignment-results-and-cron-duplicates
- fix: Merge pull request #6520 from carverauto/fix/config-invalidator-bounded-mapper
- fix: Merge pull request #6522 from carverauto/fix/snmp-credential-form-selects
- fix: Merge pull request #6523 from carverauto/fix/snmp-compile-batched-lookups
- fix: Merge pull request #6526 from carverauto/fix/large-ingestion-gate-advisory-lock-check
- …and 280 more
Architecture
- Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed
Added bounded contexts (1)
- github.com/carverauto/serviceradar
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
carverauto/serviceradar was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 3121e09f106b88bd53b3353b9af07d27f1d6fc4d — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-b8b1a43ae4c3.