Skip to content
CAI
Software that uses CAICheck a score

Netflix/atlas

62.6

Adequate · 11 November 2026

52.9k

lines of production code

Scala

primary language

8

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Added utility scripts for AWS IAM credential management and publish testing

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

Initial configuration for LWC API service

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

Introduce LSP API with WebSocket endpoints for ASL and URI metrics

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

Introduce LWC event processing client and typed filtering

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

Introduce Spring Boot auto-configuration for LWC event processing

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

Introduce URI parser with correct percent-encoding handling

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

Introduce composable glossary system for LSP completions and hover docs

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

Introduce configurable chart theming and new rendering components

The chart rendering engine now supports configurable themes via the \atlas.chart\ configuration, allowing users to define styles for images, canvases, grids, axes, legends, and warnings. This change introduces a suite of new graphics components—including \Block\, \Legend\, \TimeAxis\, \TimeGrid\, \ValueAxis\, \Heatmap\, and \TimeSeriesStack\—which handle the layout and drawing of chart elements. Users will see these new components in action for time series graphs, heatmaps, and legends, with the ability to customize visual styles such as colors, strokes, and fonts through the theme configuration.

repository · high confidence

Introduce configurable data source URI rewriting and streaming evaluation infrastructure

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

Introduce core model infrastructure and expression types

This change adds foundational components to the expression model, including new files for tracking memory block statistics (BlockStats), defining event expressions (EventExpr), normalizing query expressions (ExprNormalizer), and managing item identifiers (ItemId, ItemIdCalculator). It also introduces a StylePassthrough trait for handling style settings in typed words and adds a CustomVocabulary class to load custom operations and averages from configuration. Additionally, the Extractors object is removed, and existing core classes like DataExpr, EvalContext, Expr, and ResultSet are updated to support these new structures and improve internal handling.

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

Introduce stateful online algorithm operators and bounded rolling buffers

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

Introduces AST type system and diagnostic infrastructure for the stack language

This change adds the foundational type system and error-handling structures for the stack language's abstract syntax tree (AST). Users benefit from more precise parameter descriptions and improved diagnostic reporting, as new types like \Diagnostic\, \IsNumber\, and \Parameter\ are introduced to support typed parameters and span-based error messages in stack language expressions.

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

Introduces default configuration for the Atlas evaluation engine

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

New PostgreSQL database backend for Atlas metrics storage

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

New chart model definitions and configuration enums

This change introduces several new model classes and enums in the chart model package to support advanced charting features. HeatmapDef defines configuration for heatmap plots, including color scales and bounds. Layout.java specifies image sizing modes (canvas, image, image width, image height). PlotDef serves as the central definition for a plot, incorporating data, axis settings, and optional heatmap configurations, with logic to handle bounds and stacked/area rendering. Scale.java adds support for logarithmic, log-linear, power-of-2, and square-root scales. TickLabelMode allows suppressing tick labels or using decimal, binary, or duration formats. LegendType, LineStyle, and VisionType are also defined or moved to this package to standardize chart rendering options.

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

New chart rendering components and scale types

This change introduces several new graphics primitives and scale types for the charting library. It adds support for a log-linear scale type, which uses powers of 10 with linear interpolation between them to better emphasize smaller values in large ranges, and a new heatmap rendering component that visualizes data counts across time and value buckets. Additionally, it introduces new element types for drawing time series as areas, spans, and stepped lines, as well as a new legend entry component that can display summary statistics (max, min, avg, last, total, count) and supports binary and duration unit prefixes for tick labels.

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

New configuration files for LWC API and memory-based standalone deployment

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

New high-performance primitive collections and utility classes

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

New utility classes for host-based query rewriting, ID sanitization, and JSON deserialization

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

Removals

Removal of DefaultAwsClientFactory AWS client builder

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

Removal of legacy Json.scala companion object

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

Remove deprecated Spray-based HTTP server implementation

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

Behavioural changes

Chart rendering now supports font fallback lists for improved character coverage

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

Charting engine refactored with new graph engine and JSON formats

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

Configurable LWC Events settings via reference.conf

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

Configurable chart rendering, theming, and limits

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

Configurable index rebuild frequency and new vocabulary/normalization settings

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

Database core refactored for performance and new aggregation capabilities

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

Introduce Spring-based dependency injection for LWC API configuration

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

Introduce expression type classification for LWC subscriptions

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

Introduce startup delay and stream management for LWC API

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

Introduction of a new validation rule framework with optimized tag checking

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

Migrate Spring integration from Akka to Apache Pekko

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

Migrate from Akka to Pekko

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

Migrate webapi configuration to Spring Framework

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

Migrate webapi from Akka to Pekko and refactor request handling

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

New JSON library implementation (Jackson 3) with updated parser helpers

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

New Pekko-based configuration for request limiting and actor management

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

Project setup modernized with Scala 2.13, Scalafmt 3.11.5, and new contributor documentation

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

Refactor graph evaluation into new configuration and legend modules

The graph evaluation logic in \atlas-eval\ has been reorganized into dedicated components: \DefaultSettings\ now centralizes chart rendering defaults (such as step size, theme, and metadata settings) from configuration, \GraphConfig\ manages the resolution of time ranges, step sizes, and graph definitions for individual requests, and \SimpleLegends\ provides automatic, human-readable legend generation for streaming data by analyzing expression key-value pairs. These changes streamline how graph parameters are processed and improve the clarity of chart labels for users.

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

Refactored normalization pipeline to support sum metrics and out-of-order data handling

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

Removal of AWS service endpoint configuration file

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

Replace LazyTagIndex with RoaringBitmap-based index and update query APIs

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

Spring-based configuration for the Evaluator module

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

Stack language interpreter adds execution budgeting and structured type system

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

Standalone server now uses Spring for dependency injection

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

Standalone service configuration migrated to Pekko and Spring Boot conventions

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

Web API configuration overhaul with new validation and graph engine support

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

Test coverage

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.

Dependencies

Migrate build system to sbt 2 and Apache Pekko

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

Migrate build system to sbt and update core dependencies

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Baseline

  • First survey — no prior run to compare against. CAI 63.

Lenses

  • Code Health 57
  • Architecture 99
  • Maturity 64
  • Readiness 63
  • Security 66
  • Performance 97

Changes since last survey

  • 300 commits — 279 feature/other, 21 fixes

By area

  • project/Dependencies.scala — 95 commits
  • atlas-core/src — 69 commits
  • atlas-pekko/src — 26 commits
  • atlas-eval/src — 20 commits
  • .github/workflows — 19 commits
  • (repo) — 11 commits
  • atlas-webapi/src — 11 commits
  • atlas-chart/src — 10 commits
  • project/plugins.sbt — 9 commits
  • atlas-lwcapi/src — 7 commits
  • project/build.properties — 6 commits
  • (root) — 5 commits
  • atlas-lsp/src — 4 commits
  • atlas-lspapi/src — 2 commits
  • atlas-lwc-events/src — 2 commits
  • atlas-lsp/test-client — 1 commit
  • atlas-postgres/src — 1 commit
  • project/GitVersion.scala — 1 commit
  • project/SonatypeSettings.scala — 1 commit

Notable commits

  • fix: build: fix sbt 2 deprecation warnings (#2005)
  • fix: chart: fix datapoint count and large step overflow (#2011)
  • fix: chart: fix duplicate ticks with duration labels (#1857)
  • fix: chart: fix duration label corner case (#1858)
  • fix: core: fix ArrayIndexOutOfBoundsException (#1833)
  • fix: core: fix alignStart for last interval (#1849)
  • fix: core: fix bug in ref-primitive maps (#1827)
  • fix: core: fix interner segment/slot hash clustering (#1934)
  • fix: core: fix late updates for memory db (#1847)
  • fix: core: fix lessThan matching in RoaringTagIndex (#1880)
  • fix: eval: fix flaky state machine in EvaluatorSuite (#1895)
  • fix: fix flaky EvaluatorSuite "create processor from resource uri"
  • fix: fix log4j binding for slf4j (#1830)
  • fix: fix step rounding for unusual time ranges (#1997)
  • fix: lwcapi: fix hash code for Subscription (#1842)
  • fix: make: fix one-jar classpath extraction in CI (#1950)
  • fix: pekko: fix ByteStringInputStream zero-length read (#2012)
  • fix: pekko: fix endpointPathPrefix segment matching (#1952)
  • fix: pekko: fix flaky droppedQueueFull assertion (#1958)
  • fix: postgres: fix SQL injection in identifier escaping (#1912)
  • …and 280 more

Architecture

  • 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 11 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 29e16e5bcab3ecb743de869e026a69eba950b9ad — the exact code this score is about.
  • Scored under rubric-2026.11.2 — 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.29+preprod-106b68c3c303.