Netflix/atlas

This system is a high-performance time-series metrics platform that ingests, stores, and queries metric data using a custom stack-based query language. It provides a comprehensive charting engine for visualizing time-series data with various scales and themes, alongside a streaming evaluation engine for processing low-cardinality events and metrics. The architecture supports flexible storage backends, including in-memory and PostgreSQL databases, and exposes functionality via a modern web API and a Language Server Protocol interface for developer tooling.

30 changes.

The project underwent a comprehensive modernization, migrating the build infrastructure to sbt 2 and Scala 2.13, and shifting the actor framework from Akka to Apache Pekko. Core components were significantly refactored for performance, including replacing legacy indexing with RoaringBitmaps, optimizing data structures, and rewriting the charting engine. This period also involved removing deprecated dependencies, standardizing test suites with MUnit, and enhancing configuration flexibility across the codebase.

24 changes.

The project migrated its actor framework from Akka to Pekko and adopted Spring Boot for dependency injection, significantly refactoring the standalone server and LWC API configurations. This period also introduced comprehensive charting capabilities with new scale types and theming, while establishing robust testing and performance benchmarking suites across core, evaluation, and charting modules.

29 changes.

This period focused on migrating the actor system from Akka to Apache Pekko, including updating Spring integration and configuration structures. It also introduced significant new capabilities for Low-Cardinality Window (LWC) events, PostgreSQL storage, and stateful online algorithm operators, accompanied by extensive performance benchmarking and test coverage.

5 changes.

This period focused on enhancing the Atlas Language Server with a composable glossary system and WebSocket API support for richer query completions and documentation. Concurrently, the codebase migrated its JSON serialization stack to Jackson 3 and introduced a robust URI parser to correctly handle percent-encoding in metric queries.

The charting library now supports a log-linear axis scale, which applies logarithmic spacing at powers of 10 while remaining linear between them to better visualize data with large ranges. This is implemented via new \LogLinear\ and \Scales\ modules that handle the mapping logic. Additionally, a new \Element\ trait hierarchy is introduced to standardize how chart components (such as text or lines) report their dimensions, supporting both fixed and variable width/height calculations.

atlas-chart/src/main/scala/com/netflix/atlas/chart/graphics · high confidence

New shell scripts have been added to the repository to support AWS integration and local testing. The \meta-iam-url.sh\ script constructs the URL for retrieving IAM security credentials from the instance metadata service. The \write-aws-credentials.sh\ script consumes this metadata output and formats it into a standard AWS credentials file at \\~/.aws/credentials\, enabling local usage of temporary IAM role credentials. Additionally, \publish-test.sh\ provides a looped test client that sends sample gauge metrics to the local publish API endpoint for validation purposes.

scripts · high confidence

The graphing component now automatically generates human-readable legends for time-series expressions when no explicit legend is provided. A new \SimpleLegends\ helper analyzes query key-value pairs and grouping structures to construct descriptive labels, ensuring that charts display meaningful names by default while preserving any user-defined legends.

atlas-eval/src/main/scala/com/netflix/atlas/eval/graph · high confidence

Adds the \reference.conf\ file for the \atlas-lwcapi\ module, defining default settings for the Low-Cardinality Web API. This includes configuration for registration steps, startup delays, queue and batch sizes, expression caching TTL, and cluster expression filtering. It also registers the API endpoints (Evaluate, Expression, Streams, Subscribe) under the Pekko framework.

atlas-lwcapi/src/main/resources · high confidence

The atlas-lspapi module now exposes a new Language Server Protocol (LSP) API accessible via WebSocket connections at the /lsp/metrics/asl and /lsp/metrics/uri paths. This feature enables clients to interact with Atlas metrics using the LSP standard, supporting both ASL (Atlas Scripting Language) and URI-based metric queries. The implementation includes a dedicated WebSocket flow that handles JSON-RPC message exchange, automatically managing server lifecycle per connection and safely ignoring binary messages to maintain connection stability. Configuration for the glossary files and API endpoints is provided in the new reference.conf, and the module includes comprehensive tests to verify WebSocket upgrades and message handling.

atlas-lspapi · high confidence

This change introduces the core infrastructure for the new LWC events module. It adds a new \LwcEventClient\ trait and implementation to handle event submission and processing, including a pre-filter capability to optimize expensive transforms. A new \TypedLwcEventFilter\ is added to support typed dimensions with custom comparison logic, splitting queries into indexed and post-filter stages for more efficient matching. Additionally, \ExprUtils\ provides helper functions for parsing data and event expressions and converting Atlas queries to Spectator queries.

atlas-lwc-events/src/main/scala · high confidence

The \atlas-spring-lwc-events\ module now provides a Spring \@Configuration\ class that automatically registers an \LwcEventClient\ bean. This client switches between a remote processing mode (enabled by default via \atlas.lwc.events.enabled\) and a local debugging mode that uses preconfigured subscriptions defined in \reference.conf\. A corresponding test suite verifies that the module loads correctly within a Spring application context.

atlas-spring-lwc-events · high confidence

Added a new \UriParser\ component in \atlas-core\ that parses URI strings into structured \ParsedUri\ objects while preserving position spans. Unlike simple string splitting, this parser correctly handles percent-encoded characters (such as \%26\ for ampersands) within query values, ensuring that operators like \:each\ are not incorrectly broken up during parsing. It supports standard URI components including scheme, authority (host and port), path, and query parameters, with built-in percent-decoding and UTF-8 support.

atlas-core/src/main/scala/com/netflix/atlas/core/uri · high confidence

The Atlas LSP now supports a composable glossary system that powers completions, hover documentation, and validation for query expressions. Glossary data is defined as JSON fragments containing metrics, tag keys, and tag values, which the LSP automatically discovers from the classpath (under META-INF/atlas/glossary/) and merges with any additional files specified in the application configuration. This allows different teams or libraries to ship their own metric and tag definitions that are combined at runtime, providing richer, context-aware suggestions and documentation in supported editors.

atlas-lsp · high confidence

The streaming evaluation library now supports rewriting data source URIs based on namespace configuration, allowing users to map logical namespaces to specific backend hosts via a new \DataSourceRewriter\ and \ConfigRewriter\. This change also introduces the \EddaGroupsLookup\ stage to fetch and refresh Eureka metadata for data sources, adds the \EvalDataRateCollector\ to track input, intermediate, and output data volumes per expression, and implements the \TimeGrouped\ operator to aggregate datapoints into time buckets with configurable buffer limits and metrics for dropped or buffered data. Supporting utilities like \EvaluationFlows\ (for stream management and event counting), \FillRemovedKeysWith\ (to handle key removals in maps), \OnUpstreamFinish\ (for delayed termination actions), and \ReplayLogging\ (for trace-level event logging) are added to enhance stream control, debugging, and monitoring capabilities.

atlas-eval/src/main/scala/com/netflix/atlas/eval/stream · high confidence

This change adds a suite of new graphics components to the charting library, including a vertical Block layout, configurable ChartSettings for themes and fonts, and dedicated rendering classes for Legends and LegendEntries (supporting stats display). It also introduces a new Heatmap visualization type with its own legend entry, along with supporting utilities for text rendering, styling, and tick mark calculation.

repository · high confidence

This change introduces a new base trait \OnlineAlgorithm\ and a factory method to support stateful, streaming time-series operators such as \:rolling-sum\, \:rolling-mean\, \:rolling-min\, \:rolling-max\, \:cumulative-max\, \:delay\, and others. These operators now maintain internal state (captured via \AlgoState\) to handle continuous data streams, including proper handling of NaN values and state reset logic. To prevent memory exhaustion from large user-supplied windows, the new \RollingBuffer\ implementation enforces a maximum window size of 86,400 elements (one day at 1s resolution), capping potential heap usage for window-based operations.

atlas-core/src/main/scala/com/netflix/atlas/core/algorithm · high confidence

Adds a new \reference.conf\ file that establishes default settings for the \atlas.eval\ module. This configuration defines streaming parameters such as backend connection patterns, data limits, and compression options, while also providing default themes (light and dark) with specific color palettes for graph rendering. It further configures graph engine support, legend simplification, and host rewriting rules, giving users a baseline to customize evaluation behavior without modifying code.

atlas-eval/src/main/resources · high confidence

This change introduces a new \PostgresDatabase\ implementation that stores time-series blocks as rows in PostgreSQL tables, enabling Atlas to query metrics directly from a Postgres instance. The feature includes a \PostgresService\ for managing database connections and initialization, a \PostgresTagIndex\ for delegating tag lookups to SQL, and utility classes (\SqlUtils\, \CopyBuffer\, \BinaryCopyBuffer\, \TextCopyBuffer\) to handle SQL generation and efficient data ingestion via the PostgreSQL COPY protocol.

atlas-postgres/src/main · high confidence

The chart model package now includes new enums that define configurable options for chart rendering. Layout modes (Canvas, Image, Image Width, Image Height) allow users to control whether the image or canvas dimensions are fixed. Scale types (Linear, Logarithmic, Log-Linear, Power of 2, Sqrt) enable explicit control over Y-axis mapping, including the new log-linear option. Tick label modes (Off, Decimal, Binary, Duration) determine how Y-axis values are formatted, supporting metric prefixes, binary prefixes, and human-readable durations. Additionally, Legend types (Off, Labels Only, Labels With Stats) and Line styles (Line, Area, Stack, VSpan, Heatmap) provide finer control over visual presentation, while VisionType has been moved to the model package to support color-blindness simulation.

atlas-chart/src/main/scala/com/netflix/atlas/chart/model · high confidence

The distribution now includes dedicated configuration files to support the new LWC API and a memory-backed standalone mode. \conf/lwcapi.conf\ and \conf/lwcapi-2.conf\ define the Pekko-based API endpoints (Evaluate, Expression, Subscribe, Stream) and set the LWC API port to 7102. \conf/memory.conf\ configures a \MemoryDatabase\ with a 10-second step, sets the main server port to 7101, and registers the \LocalPublishActor\ and \PublishApi\ for local data ingestion. Additionally, \conf/log4j2.xml\ provides an alternative logging setup that splits output into \app.log\, \client.log\, and \server.log\ with size-based rotation.

conf · high confidence

Added a suite of specialized utility classes to the core util package to improve performance and reduce memory overhead. This includes open-addressing hash maps and sets for primitive types (IntIntHashMap, LongIntHashMap, IntHashSet, LongHashSet, DoubleIntHashMap) and reference types (IntRefHashMap, RefDoubleHashMap), which avoid boxing overhead. Also added immutable map views (ConcatMap, FilteredMap) for efficient tag map manipulation without materializing new collections, a BoundedPriorityBuffer for top-K computations, and various I/O wrappers (ByteBufferInputStream, CharBufferReader, FastGzipOutputStream).

atlas-core/src/main/scala/com/netflix/atlas/core/util · high confidence

Added three new utility classes to the evaluation module: HostRewriter allows query expressions to be automatically restricted based on the hostname used to access the service; IdParamSanitizer cleans up graph URI parameters by replacing values that resemble UUIDs, IPs, or instance IDs with a generic 'default' value; and SortedTagMapDeserializer provides a custom Jackson deserializer for efficient parsing of tag maps into SortedTagMap instances.

atlas-eval/src/main/scala/com/netflix/atlas/eval/util · high confidence

The DefaultAwsClientFactory class, which was responsible for constructing AWS service clients based on configuration settings (such as connection timeouts, retry policies, and proxy settings), has been removed from the codebase. This change eliminates the legacy AWS client instantiation logic that relied on the older AWS SDK client configuration model.

atlas-aws/src/main/scala · high confidence

The \com.netflix.atlas.json.Json\ companion object has been removed from the codebase. This change eliminates the centralized static API that previously handled JSON encoding and decoding using Jackson, including support for Smile format, Joda-Time modules, and Manifest-based type resolution. Users relying on \Json.encode\, \Json.decode\, or related factory methods will need to migrate to the current JSON handling implementation.

atlas-json/src/main · high confidence

The \atlas-akka\ module has removed its legacy HTTP server implementation built on the deprecated Spray library. This change deletes the core server components (\WebServer\, \RequestHandlerActor\, \ServerStats\), the custom routing directives (\CustomDirectives\), and the associated configuration (\reference.conf\) and tests. Users relying on this module for HTTP serving must migrate to the Akka-HTTP based implementation.

atlas-akka · high confidence

The charting library now allows specifying a list of fonts for text rendering, enabling automatic fallback to secondary fonts when the primary font cannot display specific characters (such as emojis or special symbols). This is implemented via a new \FontSet\ utility that iterates through provided fonts to find the best match for each Unicode code point, ensuring more robust text display across different systems and character sets.

atlas-chart/src/main/scala/com/netflix/atlas/chart/util · high confidence

The charting module has been significantly refactored to replace the legacy RRD4j-based rendering with a new, native Scala implementation (DefaultGraphEngine) and to modernize the JSON output formats. The legacy Rrd4jGraphEngine and Palette files have been removed, and the core GraphDef model has been migrated to a new package (com.netflix.atlas.chart.model). A new V2JsonGraphEngine provides an experimental, fully standard JSON format that includes all metadata and supports incremental data streaming, while a new StdJsonGraphEngine ensures non-numeric values like NaN and Infinity are properly quoted for standard parsers. The default 'json' format remains for backwards compatibility but is no longer used on v2 endpoints. Additionally, the CSV output now uses ISO 8601 date formatting and the PNG engine now includes source metadata in the image headers.

atlas-chart/src/main/scala/com/netflix/atlas/chart · high confidence

A new reference.conf file has been added to the atlas-lwc-events module, defining default configuration values for the LWC events system. This includes settings for the base API URI, configuration and evaluation endpoints, refresh and heartbeat frequencies, buffer sizes, batch sizes, payload limits, and maximum group counts. Users can now override these defaults to tune performance, manage memory usage, and adjust communication intervals with the LWC API.

atlas-lwc-events/src/main/resources · high confidence

A new reference configuration file introduces user-controllable settings for chart appearance and behavior. Users can now select between light and dark themes, which define specific colors for backgrounds, lines, text, grids, and legends. The configuration also allows customization of rendering hints (such as antialiasing) and specifies a set of fallback fonts (including NotoSans variants) to ensure consistent text rendering. Additionally, strict limits are enforced on image dimensions (max 2000x1000), zoom levels (max 2.0), and chart complexity (max 50 legend lines, 5 Y-axes) to prevent excessive resource usage.

atlas-chart/src/main/resources · high confidence

The memory database index rebuild frequency is now explicitly configurable via the \rebuild-frequency\ setting (defaulting to 40s), replacing the previous implicit timing. Additionally, the configuration introduces a \normalize\ section to define prefix and suffix keys for query clause ordering, and a \vocabulary\ section that supports custom words and defines Netflix-specific custom averages (\node-avg\ and \eureka-avg\) with their respective base queries and tag keys.

atlas-core/src/main/resources · high confidence

This change introduces several foundational updates to the core model layer. A new \ItemId\ class replaces the previous identifier mechanism, using SHA1 hashes with optimized comparison and hashing via Java VarHandles. An \ExprNormalizer\ is added to standardize expression legends, statistics, and query clause ordering based on configurable prefix/suffix keys. \BlockStats\ provides runtime metrics for memory block usage via Spectator. The \Expr\ trait now implements \StackItem\, and \TimeSeriesExpr\ gains a \finalGrouping\ method. Additionally, \ArrayTimeSeq\ equality now includes \dsType\, and the legacy \Extractors\ object is removed.

atlas-core/src/main/scala/com/netflix/atlas/core/model · high confidence

The database core in \atlas-core/src/main/scala/com/netflix/atlas/core/db\ has been significantly refactored to improve performance and add new features. \AggregateCollector\ now supports combining collectors and avoids per-block allocations by using explicit loops. \BlockStore\ and \MemoryBlockStore\ have been updated to use compressed block types and support rollup blocks, with improved block alignment logic. \MemoryDatabase\ now derives index membership directly from the data map to prevent orphaned series, uses a configurable rebuild frequency, and accepts a \Registry\ for metrics. \Limits\ now uses \ConfigManager\ for dynamic configuration. A new \SimpleStaticDatabase\ class provides a static database implementation with configurable line and datapoint limits. \DataSet\ has been updated to include timer-style metrics and percentile support, and \TimeSeriesBuffer\ has been made final with optimized block aggregation.

atlas-core/src/main/scala/com/netflix/atlas/core/db · high confidence

The LWC API module now uses Spring for dependency injection, replacing the previous mechanism. A new \LwcApiConfiguration\ class defines Spring beans for \StartupDelayService\, \ExpressionSplitter\, and \StreamSubscriptionManager\, handling configuration and registry injection with sensible defaults. This change is accompanied by a test suite that verifies the Spring context loads correctly and that the underlying \ActorService\ remains healthy.

atlas-spring-lwcapi · high confidence

The LWC evaluation model now distinguishes between time-series and event-based expressions. A new \ExprType\ enum defines \TIME\_SERIES\ and \EVENTS\ categories, and the subscription message format has been extended to include an \exprType\ field. This allows the evaluation engine to correctly route and process subscriptions based on whether they target time-series metrics or raw events.

atlas-eval/src/main/scala/com/netflix/atlas/eval/model · high confidence

The LWC API now includes a configurable startup delay service that keeps the instance reporting as unhealthy for a specified duration after launch, allowing time for clients to connect before the instance begins accepting data. Additionally, a new Streams API endpoint has been added to browse and inspect current stream summaries, aiding in debugging and operational visibility. The underlying subscription management has been refactored to use a source-based queue handler, ensuring that resources are properly cleaned up when streams are unregistered and preventing memory leaks.

atlas-lwcapi/src/main/scala · high confidence

The validation module now uses a new \Rule\ trait and \TagRule\ helper to structure validation logic. \Rule\ provides a unified interface for validating both \Map\[String, String\]\ and Spectator \Id\ objects, with a factory method to load rules from configuration. \TagRule\ optimizes the hot path by iterating directly over key-value pairs in \SortedTagMap\ and \Id\ instances, avoiding object allocation by returning \null\ for valid checks. This change refactors how validation rules are defined and executed, improving performance for tag-based validations.

atlas-core/src/main/scala/com/netflix/atlas/core/validation · high confidence

The Spring configuration module now uses Apache Pekko instead of Akka for actor system management. This change updates the underlying actor framework, requiring users to ensure their configuration aligns with Pekko's expectations. The module provides Spring beans for the ActorSystem, Materializer, and associated services, facilitating the transition for existing applications relying on this integration.

atlas-spring-pekko · high confidence

The \atlas-pekko\ module has been migrated from Akka to Apache Pekko, updating all internal imports and dependencies to use the \org.apache.pekko\ namespace. This change replaces the underlying actor system and HTTP server implementation while preserving the existing public API and configuration structure for users.

atlas-pekko/src/main/scala · high confidence

The webapi module now uses Spring Framework for dependency injection, replacing the previous mechanism. This change introduces a new WebApiConfiguration class that defines Spring beans for the database supplier and database instance, and includes corresponding tests to verify the Spring context loads correctly.

atlas-spring-webapi · high confidence

The webapi module has migrated its underlying actor framework from Akka to Apache Pekko, updating imports and dependencies accordingly. This change introduces a new imperative request context model (ImperativeRequestActor) that replaces the previous actor-to-actor message passing pattern for graph and tag requests, allowing for more direct error handling and response completion. Additionally, the \RequestId\ class and \TagsRequestActor\ have been removed as part of this architectural cleanup, and the \GraphRequestActor\ now utilizes a \Grapher\ component to handle image generation, separating the rendering logic from the request handling.

atlas-webapi/src/main/scala · high confidence

The \atlas-json3\ module introduces a new JSON serialization and deserialization implementation based on Jackson 3 (\tools.jackson\), replacing the previous \com.fasterxml.jackson\ stack. This includes a new \Json\ object that configures the Jackson 3 \JsonMapper\ and \SmileMapper\ with specific features such as \NON\_ABSENT\ property inclusion, timestamp-based date writing, and fast double parsing. The \JsonParserHelper\ utility has been migrated to use Jackson 3 APIs (e.g., \PROPERTY\_NAME\ instead of \FIELD\_NAME\, \getString\ instead of \getText\) and now includes a \skipNext\ method for easier traversal. Additionally, a \JsonSupport\ trait and associated serializer modifier allow objects to opt into custom JSON encoding via \toJson\. A JMH benchmark suite (\SeqDeser\) has been added to \atlas-jmh\ to measure the performance of deserializing JSON and Smile arrays vs. lists.

atlas-jmh/src/main/scala/com/netflix/atlas/json3, atlas-json3 · high confidence

The service now uses a new Pekko-based configuration structure (\reference.conf\ and \metered-mailbox.conf\) to manage actor mailboxes, request handling, and caller-aware concurrency limits. Users can now configure fair-share limiting with penalty decay, define per-endpoint budgets, and enable access logging with sensitive header redaction. The default mailbox type has changed to \UnboundedMeteredMailbox\, and new settings allow for CORS control, compression, and linking to agent-facing documentation.

atlas-pekko/src/main/resources · high confidence

The project has upgraded its build configuration to use Scala 2.13.11 and Scalafmt 3.11.5 (dialect Scala213Source3), enforcing stricter formatting rules and removing the one-jar dependency in favor of a custom launcher-based assembly. Contributor workflows are now supported by new CLAUDE.md and CONTRIBUTING.md guides that document the SBT-based build process, license header checks, and IDE integration via Metals/Bloop, while the version is now managed directly in build.sbt rather than version.sbt.

(repo-wide) · high confidence

The normalization layer in \atlas-core\ has been restructured to improve robustness and add new metric types. \NormalizationCache\ now accepts \ItemId\ and tags directly instead of wrapping them in \Datapoint\ objects, and introduces dedicated caches for sum and gauge metrics. The previous \LastValueFunction\ for gauges was replaced by \MaxValueFunction\, which uses a new \RollingValueFunction\ to aggregate values using max logic, allowing for out-of-order updates within a step window. A new \SumValueFunction\ was added to support sum data types by aggregating values with addition. Additionally, a new \DedupValueFunction\ was introduced to buffer and deduplicate values, handling cases where data is reported out of order from multiple nodes. All \ValueFunction\ implementations now implement \AutoCloseable\ to ensure proper resource cleanup.

atlas-core/src/main/scala/com/netflix/atlas/core/norm · high confidence

The \reference.conf\ file in the \atlas-aws\ module, which previously defined hardcoded AWS service endpoints for regions such as us-east-1, eu-west-1, and ap-southeast-1 across services like S3, EC2, and CloudWatch, has been removed. This change eliminates the local configuration of these regional endpoints, likely shifting responsibility for endpoint resolution to the underlying AWS SDK or external configuration sources.

atlas-aws/src/main/resources · high confidence

The tag indexing system has been migrated from the previous LazyTagIndex (which used BitSet and Trove collections) to a new RoaringTagIndex backed by RoaringBitmaps, significantly reducing memory overhead and improving query performance. This change introduces a new Java helper class, LazyOrBitmap, to support efficient lazy OR operations across bitmaps. Consequently, the TagIndex API has been updated: findKeys now returns a List\[String\] instead of List\[TagKey\], and item IDs are handled via a custom ItemId class rather than BigInteger. The BatchUpdateTagIndex now supports filtering items during rebuilds and uses Caffeine for caching instead of Guava, while also exposing an iterator over indexed items.

atlas-core/src/main/scala/com/netflix/atlas/core/index · high confidence

The \atlas-spring-eval\ module now uses Spring Framework for dependency injection to configure the \Evaluator\ instance. A new \EvalConfiguration\ class defines a Spring \@Bean\ that creates the \Evaluator\ using an optional \Config\, \Registry\, and \ActorSystem\ (backed by Pekko), falling back to defaults if not provided. This replaces previous configuration mechanisms with a standard Spring-managed lifecycle, verified by a new test suite ensuring the context loads and provides the bean correctly.

atlas-spring-eval · high confidence

The stack language interpreter now protects against excessively expensive expressions by introducing an \EvalBudget\ that limits the total number of operations, preventing scenarios where nested looping operators like \:each\ and \:map\ cause effectively infinite execution. Additionally, the language gains a structured AST type system via \TypedWord\, allowing words to declare explicit input and output data types for better validation and auto-completion, while \Vocabulary\ now supports dependency declarations to automatically aggregate words from dependent vocabularies.

atlas-core/src/main/scala/com/netflix/atlas/core/stacklang · high confidence

The standalone entry point has been refactored to initialize the application context using Spring's AnnotationConfigApplicationContext instead of the previous mechanism. This change enables Spring-based dependency injection for the standalone server, allowing configuration and beans to be managed through the Spring framework while maintaining the existing command-line interface for loading configuration files.

atlas-standalone/src/main/scala · high confidence

The standalone application's resource configuration has been updated to reflect the migration from Akka to Pekko and the adoption of Spring for dependency injection. A new application.conf defines Pekko-specific actor and API endpoint settings, while static.conf provides default configurations for the LocalDatabaseActor and web APIs (Tags, Graph, Expr). Additionally, log4j2.xml is introduced with the shutdown hook disabled to prevent conflicts, ensuring consistent logging behavior for the standalone mode.

atlas-standalone/src/main/resources · high confidence

The web API configuration has been significantly expanded to support new capabilities and stricter data handling. The graph API now allows configuring multiple output engines (such as CSV, TSV, and various JSON formats) and exposes a customizable vocabulary. New validation rules have been added for published data, including checks for key length, name/value length, valid characters, and reserved key prefixes (atlas., nf.), along with a limit on permitted tags per datapoint. Additionally, the fetch chunk size is now configurable, and the expression API's auto-completion excludes specific deprecated or low-value words.

atlas-webapi/src/main/resources · high confidence

Added JMH benchmark for tag validation strategies; Added JMH benchmarks for LWC datapoint encoding and message parsing; Added JMH benchmarks for RoaringTagIndex query performance and allocation; Added JMH benchmarks for core model performance hot paths; Added JMH benchmarks for core utility performance; Added JMH benchmarks for graph engine performance; Added JMH benchmarks for publish payload encoding and decoding; Added JMH benchmarks for stacklang expression parsing and string splitting; Added JavaTestRule for validation testing; Added MUnit test suites for model aggregation and message serialization; Added MUnitRouteSuite base class for route testing; Added Pekko-specific JMH benchmarks for URI parsing, byte string reading, and stream monitoring; Added benchmark for ByteString JSON decoding performance; Added comprehensive test coverage for lwcapi components; Added comprehensive test suite for Atlas Postgres integration; Added comprehensive test suites for core utility classes; Added comprehensive test suites for online algorithm state and operators; Added test coverage for chart dimension validation and JSON encoding; Added test coverage for host rewriting, ID sanitization, and tag map deserialization; Added test coverage for stack language interpreter features; Added test coverage for standalone application lifecycle; Added test coverage for streaming evaluation components; Added test fixtures for streaming evaluation with 5s and 60s frequencies; Added test resources for graph API validation; Added test suite for the Pekko migration; Added test suites for model operators and utilities; Added test suites for tag validation rules; Added tests for font fallback and migrated PNG image tests to MUnit; Added unit tests for LWC events processing and filtering; Added unit tests for chart graphics components; Added unit tests for graph configuration, URI parsing, and legend generation; Disable antialiasing in chart rendering tests; Expanded test coverage for database block handling and aggregation; Migrate JSON tests from ScalaTest to MUnit; Migrate index tests to MUnit and add coverage for index statistics and query planning; Migrate norm module tests to MUnit; Migrate webapi tests to MUnit and Pekko; Removed DefaultAwsClientFactorySuite test; Test configuration for random server port.

The build infrastructure has been upgraded from sbt 0.13 to sbt 2.0.8, which necessitates migrating the underlying actor framework from Akka to Apache Pekko (versions 1.7.0 and 1.4.0). This change also updates the default Scala version to 2.13.18 with cross-building support for Scala 3.9.0, replaces the legacy log4j 1.x with log4j 2.26.1, and upgrades Jackson to version 3.2.2. Additionally, the build now enforces Java 17 compatibility and switches the test framework from ScalaTest to MUnit.

project · high confidence

The project build has been migrated from the legacy Build.scala format to build.sbt, introducing a modular structure with new sub-projects such as atlas-pekko, atlas-json3, and atlas-lsp. This change includes a significant dependency update, migrating the underlying actor framework from Akka to Pekko, and updating the LSP test client to use Vite 6.4.2 and Monaco Editor 0.55.1.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 61 → 62 (+1.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 95 → 90 (-4.5)
• Architecture 100 → 98 (-1.5)
• Maturity 52 → 55 (+2.7)
• Readiness 64 → 57 (-7.6)
• Security 58 → 72 (+14.3)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No exposed public API
• Off-boarding risk: anonymized user #1
• …and 3 more

• ApproxDistinct.estimateDistinct (cognitive 23) (atlas-core/src/main/scala/com/netflix/atlas/core/model/MathExpr.scala)
• AslDocumentAnalyzer.buildDocumentSymbols (cognitive 26) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.buildDocumentSymbols (cyclomatic 16) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.buildStackSourceMap (cognitive 22) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.computeGlossaryCompletions (cognitive 40) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.computeGlossaryCompletions (cyclomatic 18) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.computeUnicodeCompletions (cognitive 29) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.literalContext (cognitive 18) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• AslDocumentAnalyzer.renderNode (cognitive 22) (atlas-lsp/src/main/scala/com/netflix/atlas/lsp/AslDocumentAnalyzer.scala)
• Block.compress (cognitive 22) (atlas-core/src/main/scala/com/netflix/atlas/core/model/Block.scala)
• DefaultGraphEngine.createImage (cognitive 22) (atlas-chart/src/main/scala/com/netflix/atlas/chart/DefaultGraphEngine.scala)
• DefaultGraphEngine.createImage (cyclomatic 16) (atlas-chart/src/main/scala/com/netflix/atlas/chart/DefaultGraphEngine.scala)
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no committed lockfile, so no resolved version to grade)
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Duplicated block (10 lines × 2) (atlas-core/src/main/scala/com/netflix/atlas/core/db/DataSet.scala)
• Duplicated block (10 lines × 2) (atlas-core/src/main/scala/com/netflix/atlas/core/util/IntHashSet.scala)
• Duplicated block (10 lines × 2) (atlas-core/src/main/scala/com/netflix/atlas/core/util/RefDoubleHashMap.scala)
• Duplicated block (10 lines × 2) (atlas-core/src/main/scala/com/netflix/atlas/core/util/RefDoubleHashMap.scala)
• Duplicated block (10 lines × 2) (atlas-core/src/main/scala/com/netflix/atlas/core/util/RefDoubleHashMap.scala)
• …and 101 more

• 59 commits — 58 feature/other, 1 fixes

• project/Dependencies.scala — 18 commits
• atlas-core/src — 13 commits
• atlas-pekko/src — 6 commits
• (repo) — 4 commits
• .github/workflows — 3 commits
• atlas-eval/src — 3 commits
• atlas-lsp/src — 3 commits
• atlas-webapi/src — 3 commits
• project/plugins.sbt — 3 commits
• project/build.properties — 2 commits
• (root) — 1 commit

• fix: webapi: fix stale wiki doc link (#1976)
• change: Add Netflix-owned Common IPC metrics glossary fragment
• change: Merge branch 'main' into deps
• change: Merge pull request #1968 from mpalriwal-Netflix/main
• change: Remove obsolete wiki publishing workflow (#1975)
• change: RoaringBitmap 1.6.19
• change: bound total work for an expression (#1991)
• change: build(deps): bump actions/setup-java from 5.6.0 to 6.0.0 (#1985)
• change: core: add live event viewers to sample data (#1984)
• change: core: avoid per block allocation in aggregation (#1973)
• change: core: bound normal form conversion (#1980)
• change: core: plan and chains to cut allocation (#1986)
• change: core: reduce bitmap churn in query eval (#1972)
• change: core: remove unused TaggedItemIndex (#1983)
• change: core: render and or chains iteratively (#1982)
• change: core: walk candidates for negated terms (#1987)
• change: duration windows for :delay (#1990)
• change: duration windows for rolling operators (#1989)
• change: equalsverifier 4.5.2
• change: eval: add bounds checking in LwcMessages.parseTags (#1969)
• …and 39 more

• Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

• repository

• .

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Netflix/atlas 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.