Skip to content
CAI
Software that uses CAICheck a score

apache/livy

49.0

Weak · 14 November 2026

25.2k

lines of production code

Scala

with Java, Python

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Apache Livy is a cloud-native service that enables remote submission and management of Spark jobs and interactive sessions via a REST API. It supports batch execution, interactive REPLs for Python, Scala, and SQL, and JDBC/ODBC connectivity through a ThriftServer. The system provides robust session lifecycle management, including state recovery, access control, and authentication, alongside client libraries for Java, Scala, and Python.

How it got here

2015–2017 — Apache graduation and client API development

54 changes.

This period marks Apache Livy's graduation from the Hue incubator, involving a complete repository restructuring, namespace migration, and the removal of legacy Hue-based code. The project focused on establishing a robust Maven module structure and introducing comprehensive client-side APIs for Java, Scala, and Python to facilitate remote job submission and session management. Concurrently, significant enhancements were made to the server, including session recovery, access control, and a modernized Web UI, supported by extensive new test coverage.

2018–2026 — ThriftServer and LDAP integration

15 changes.

This period focused on expanding the ThriftServer module by extracting session logic into a dedicated component, adding comprehensive monitoring UI, and implementing robust test coverage for connection limits and data types. Concurrently, the project introduced LDAP authentication support for both the main server and ThriftServer, while also enhancing developer productivity through new Docker and Kubernetes-based local development environments.

Features

Add Kryo-based serialization utility for user data

The livy-client-common module now includes a new Serializer utility class that uses Kryo to serialize and deserialize user data into and from ByteBuffers. This change introduces a new mechanism for handling data serialization within the client, supporting classes like SerializedLambda and closures via specific Kryo serializers.

livy-client-common · high confidence

Add LDAP authentication support for Livy server

Users can now authenticate against an LDAP directory by configuring the server with LDAP provider URLs, base DNs, and optional domain suffixes. The new LdapAuthenticationHandlerImpl supports both standard LDAP binds and StartTLS for encrypted connections, allowing administrators to secure access using existing LDAP credentials.

server/src/main/scala/org/apache/livy/server/auth · high confidence

Add ThriftServer UI for monitoring JDBC/ODBC sessions

The Livy server UI now includes a dedicated view for ThriftServer sessions. This update adds a new HTML table template and JavaScript client that fetches and displays active JDBC/ODBC sessions, showing their Session ID, associated Livy Interactive Session ID (with a link to the session summary), owner, and creation time. This provides visibility into ThriftServer activity directly within the existing Livy dashboard.

thriftserver/server/src/main · high confidence

Added Scala 2.12 REPL interpreter implementation

A new SparkInterpreter class has been added for the Scala 2.12 build, enabling the Read-Eval-Print Loop (REPL) functionality to operate with this specific Scala version. This implementation configures the Scala compiler settings, manages the Spark interpreter loop, and handles classpath management for user jars, allowing users to execute interactive Scala code within Livy when running on Scala 2.12.

repl/scala-2.12 · high confidence

Client-side Python Job API for Livy

This change introduces a new client-side Python API for interacting with Livy, allowing users to submit and manage Spark jobs directly from Python scripts. The \livy.client\ module provides an \HttpClient\ to connect to a Livy server, with methods to \submit\ jobs for asynchronous execution or \run\ them immediately, as well as \add\_file\ and \add\_jar\ to manage dependencies in the remote context. Jobs are tracked via \JobHandle\, which extends \concurrent.futures.Future\ to support status monitoring, cancellation, and callback registration. The API also defines a \JobContext\ interface that exposes shared Spark contexts (SparkContext, SQLContext, HiveContext, SparkSession, etc.) to the submitted job functions.

python-api/src/main · high confidence

Enhanced Livy Web UI with detailed session and statement metadata

The Livy Web UI now displays additional metadata for batch sessions, interactive sessions, and statements. Batch session views include Owner and Proxy User columns, while interactive session views now show Session Kind alongside Owner and Proxy User. Statement views have been expanded to include Started time, Completed time, and Duration columns, providing better visibility into execution timing and progress.

server/src/main/resources/org/apache/livy/server/ui/static/html · high confidence

Initial release of Apache Livy with core session management, REPL interpreters, and ThriftServer support

This change introduces the initial codebase for Apache Livy, a cloud-native Spark job submission service. It establishes the core session management infrastructure, including the \SessionState\ model and \SessionManager\ for handling batch and interactive sessions with recovery capabilities via \SessionStore\. The release adds REPL interpreters for Python (\PythonInterpreter\) and SQL (\SQLInterpreter\), enabling interactive data analysis. Additionally, it includes a new ThriftServer module (\thriftserver\) to provide JDBC/ODBC compatibility, along with server-side configuration (\LivyConf\), JSON serialization (\JsonServlet\), and security features like LDAP authentication and access control.

repository · high confidence

Initial release of the Livy Python API client package

This change introduces the \livy-python-api\ package, providing a Python client for interacting with the Livy REST API. The package is configured via \setup.py\ and \setup.cfg\ to support Python versions 3.8 through 3.14, with dependencies on \requests\, \cloudpickle\, \responses\, and \requests-kerberos\. It adopts PEP 440 compliant versioning (using \.dev0\ instead of Maven-style \-SNAPSHOT\) and sets up the project structure for testing and distribution.

python-api · high confidence

Interactive sessions now support automatic expiration via TTL and idle timeouts

Users can now configure interactive sessions to automatically expire and be cleaned up using two new parameters: \ttl\ (time-to-live) and \idleTimeout\. The \CreateInteractiveRequest\ model accepts these optional string fields, which are validated and passed to the \InteractiveSession\ creation logic. The server enforces these limits through a new \SessionHeartbeat\ trait and a background \SessionHeartbeatWatchdog\ thread that periodically checks for expired sessions and deletes them. Additionally, the \SessionInfo\ returned by the REST API now includes the configured \ttl\ and \idleTimeout\ values, allowing users to inspect the expiration settings of their sessions.

server/src/main/scala/org/apache/livy/server/interactive · high confidence

Introduce HTTP-based Livy client implementation

Users can now connect to Livy via HTTP using the new \HttpClient\ and \HttpClientFactory\ classes located in \client-http/src/main\. This implementation allows applications to submit jobs, upload JARs and files, and manage interactive sessions over HTTP(S), including support for Kerberos/SPNEGO authentication when configured. The client is automatically discovered via the \META-INF/services\ registration, enabling seamless integration with the standard \LivyClientFactory\ SPI.

client-http/src/main · high confidence

Introduce Livy Java Client API

Added a new programmatic Java API in the org.apache.livy package, providing interfaces and classes to submit and monitor Spark jobs remotely. The API includes LivyClient for job submission (submit/run), jar/file management, and context control, along with Job and JobContext interfaces for defining job logic and accessing shared Spark contexts. A LivyClientBuilder facilitates client instantiation via URI and configuration, leveraging ServiceLoader for factory discovery, while JobHandle enables job state monitoring and listener registration.

api/src/main · high confidence

Introduce RSC driver with shared variables and Spark 4 compatibility

The RSC driver now supports shared variables across jobs, allowing users to persist and reuse state between different statements within a session via the new \JobContextImpl\ implementation. Additionally, the driver's Spark integration layer (\SparkEntries\) has been updated to detect and support Spark 4, ensuring compatibility with the latest Spark runtime while maintaining support for Spark 3.

rsc/src/main/java/org/apache/livy/rsc/driver · high confidence

Introduce client-common library for Livy client infrastructure

This change introduces the new \client-common\ module, which centralizes shared client-side components for the Livy service. It provides a type-safe configuration system (\ClientConf\) with support for typed entries, deprecation warnings, and time-string parsing, alongside a Kryo-based \Serializer\ for efficient job data serialization. The module also includes \AbstractJobHandle\ to manage job lifecycle states and listener notifications, \HttpMessages\ to define the JSON structures for the client protocol (including session details and job status), and utility classes like \BufferUtils\ for byte buffer handling. Additionally, it adds \TestUtils\ to standardize test configurations, such as pinning Spark drivers to loopback addresses for macOS compatibility.

client-common · high confidence

Introduction of Livy Web UI with session and log viewing capabilities

The Livy server now includes a built-in Web UI accessible via the /ui path, allowing users to view all active sessions (interactive, batch, and optionally ThriftServer), inspect individual session details and statements, and view session logs. The UI is built using Scalatra, Bootstrap 3.4.1, and jQuery 3.4.1, and supports reverse proxy configurations through a configurable base path. This change introduces the frontend serving infrastructure for Livy's management interface.

server/src/main/scala/org/apache/livy/server/ui · high confidence

Introduction of ScalaIterator utility class

A new ScalaIterator class has been added to the thriftserver/session module to provide a Java Iterator interface wrapper around Scala iterators, facilitating interoperability between Java and Scala collections within the Thrift server session logic.

livy-thriftserver-session · high confidence

Introduction of the Remote Spark Context (RSC) client library

This change introduces the \rsc\ module, a new client-side library for Livy's Interactive Sessions. It adds the core \RSCClient\ implementation, which manages the lifecycle of remote Spark contexts, including launching driver processes via \ContextLauncher\, handling RPC connections, and tracking job states through \JobHandleImpl\. The update also defines the \BaseProtocol\ for message serialization, \RSCConf\ for configuration management, and supporting utilities, establishing the foundation for the new remote context architecture.

rsc/src/main/java/org/apache/livy/rsc · high confidence

Livy Web UI now displays session owner, proxy user, and HTML-escaped names

The All Sessions page in the Livy Web UI has been enhanced to show the session owner and proxy user for each interactive session and batch. Session names are now HTML-escaped to prevent potential injection issues. This change is implemented in the new all-sessions.js file, which handles the rendering of the sessions and batches tables, and relies on the updated bootstrap.bundle.min.js library for UI components.

server/src/main/resources/org/apache/livy/server/ui/static/js · high confidence

New Docker-based local development environment for Livy

Developers can now spin up a local Livy and Spark cluster using Docker Compose for easier debugging and integration testing. This change adds a new \dev/docker\ directory containing a \build-images.sh\ script to assemble container images (base, Spark, and server) and a \livy-dev-cluster\ configuration for launching the stack. The environment exposes the Livy REST API on localhost:8998 and includes pre-configured remote debugging support on port 9010, allowing IDEs to attach directly to the running Livy process.

dev/docker · high confidence

New Docker-based local development environment for Livy and Spark

Developers can now run a local integration environment using Docker Compose, which spins up a Spark master, a Spark worker, and the Livy server as separate containers. This setup includes pre-configured settings for connection endpoints, resource limits (such as 1g driver memory), and logging via Log4j2, and it enables remote Java debugging on port 9010 for the Livy server to simplify local testing and debugging.

dev/docker/livy-dev-cluster · high confidence

New Helm chart for local Livy and Spark development on Kubernetes

A new Helm chart named \livycluster\ has been added to \dev/helmchart\ to simplify running a local Apache Livy and Spark environment on Kubernetes (e.g., Docker Desktop). The chart deploys a Livy StatefulSet and a Spark History Server, configuring them via a shared ConfigMap and persistent storage. It includes built-in support for ingress routing with TLS (using \ingress-nginx\ and \cert-manager\ as subcharts), remote debugging on port 9010, and optional integration with Grafana Loki for log correlation. The release also provides a validation script (\test/validate.sh\) to check license headers, version consistency, and rendered manifest correctness.

dev/helmchart · high confidence

New Java, Python, and Scala Job API examples added

The examples directory now includes new reference implementations for the Livy Job API in Java (PiApp), Python (pi\_app.py), and Scala (WordCountApp). These examples demonstrate how to initialize a Livy client, upload necessary JARs, and submit jobs—ranging from simple parallel computations to Spark Streaming and SQL operations—providing users with concrete templates for integrating with the Livy server.

examples · high confidence

New Scala API client for Livy

This change introduces a new Scala client library (\org.apache.livy.scalaapi\) that wraps the existing Java Livy client. It provides Scala-native types for job submission and monitoring, including \LivyScalaClient\ for submitting and running jobs, \ScalaJobHandle\ which implements Scala's \Future\ interface for asynchronous result handling and callbacks, and \ScalaJobContext\ for accessing shared Spark contexts and variables within jobs. Users can now interact with Livy using idiomatic Scala constructs like \Future\ and implicit conversions.

scala-api/src/main · high confidence

New development and release tooling scripts

The dev directory now includes several new scripts to support development workflows and release processes. A Python-based livy-shell script provides an interactive command-line interface for creating and managing Livy sessions. A beeline script allows users to run the Hive Beeline client against a Livy Thrift server. A merge\_livy\_pr.py utility automates the merging of GitHub pull requests into the Apache Git repository, handling conflicts and commit metadata. Additionally, a release-build.sh script streamlines the creation of signed source and binary packages (for Scala 2.11 and 2.12) and their publication to Apache Nexus, while livy-build-info.sh generates version metadata properties. License management is supported by a third-party-file.ftl template and a third-party-missing-license.properties file to track dependency licenses.

dev · high confidence

New session recovery subsystem with filesystem and ZooKeeper state stores

Livy now includes a new recovery subsystem that persists session state to enable session restoration after server restarts. This location introduces the core storage abstractions and implementations: a \StateStore\ interface with \FileSystemStateStore\ (writing to HDFS with safe-mode checks and atomic writes) and \ZooKeeperStateStore\ (using Curator with SASL and SSL/TLS support), plus a \BlackholeStateStore\ for when recovery is disabled. A \SessionStore\ manages the high-level session metadata, and a \RecoveryServlet\ exposes \/sessions/refresh\, \/batches/refresh\, and \/refresh\ operator endpoints (guarded by superuser access) to import sessions from the state store into a running server.

server/src/main/scala/org/apache/livy/server/recovery · high confidence

Session model supports TTL and idle timeout configurations

The Session class now accepts optional \ttl\ (time-to-live) and \idleTimeout\ parameters, allowing users to configure automatic session expiration based on total lifetime or inactivity. These fields are integrated into the session's core state alongside the existing name and owner, enabling the server to manage session lifecycle and cleanup more effectively.

server/src/main/scala/org/apache/livy/sessions · high confidence

Support for named sessions and proxy user impersonation in batch jobs

Users can now assign a custom name to their batch sessions and specify a proxy user when creating a job. The server-side request handling has been updated to accept these new parameters, allowing sessions to be identified by name and executed with the permissions of a different user, which facilitates access control and session management.

server/src/main/scala/org/apache/livy/server/batch · high confidence

Removals

Removal of legacy Hue-based Livy REPL and session management code

This change removes the initial code import from Hue, deleting the \livy-repl\ module and core session management classes from \livy-core\. Specifically, it eliminates the \LivyConf\ configuration class, the \SessionManager\ and \SessionFactory\ abstractions, session state tracking (\SessionState\, \StatementState\), and the interactive/batch session traits. It also removes the REPL-specific components including the \Main\ entry point, \WebApp\ servlet, and interpreter implementations for Python, Scala, and R, along with their associated test suites and resource files. This effectively strips out the standalone REPL server and its underlying session lifecycle management infrastructure.

(repo-wide) · high confidence

Removal of legacy YARN client implementation from livy-yarn

The \livy-yarn\ module has removed its original YARN application submission and management code, including the \Client\ and \Job\ Scala classes, the \ApplicationState\ trait, and associated build artifacts (\dist.xml\, \run-class.sh\, \logback.xml\). This change eliminates the initial code imported from Hue, effectively stripping out the previous mechanism for submitting and tracking YARN applications within this module.

livy-yarn · high confidence

Architecture

Thrift Server session logic moved to a dedicated module

The session management code for the Livy Thrift Server has been extracted into a new \thriftserver/session\ module. This change introduces a new set of internal classes—including \ThriftSessionState\, \StatementState\, \ColumnBuffer\, and \ResultSet\—to handle session lifecycle, statement execution, and result serialization, alongside new job implementations for catalog operations such as retrieving tables, columns, schemas, and functions.

thriftserver/session/src/main · high confidence

Behavioural changes

Added Spark 4.x Scala 2.13 interpreter implementation

The REPL now includes a new \SparkInterpreter\ class specifically for Spark 4.x and Scala 2.13. This implementation adapts the interpreter to Spark 4's API changes, such as using \ReplCompletion\ for code completion instead of reflection-based \PresentationCompilerCompleter\, and adjusting how the Scala compiler classpath is constructed to correctly handle user JARs while excluding conflicting Livy and Scala-reflect artifacts. It also updates internal bindings to use \intp.reporter.withoutPrintingResults\ and retrieves term values via \$result\ to align with Scala 2.13's \IMain\ behavior.

repl/scala-2.13 · high confidence

Added service provider configuration for RSCClientFactory

A new service provider configuration file has been added to register the RSCClientFactory implementation, enabling automatic discovery of the client factory via the Java Service Provider Interface (SPI).

rsc/src/main/resources · high confidence

Apache Livy project graduation and repository restructuring

This change reflects Apache Livy's graduation from the Hue incubator to a standalone Apache project. The repository has been restructured with a new README.md replacing the old README.rst, updated build instructions targeting Spark 3.x/4.x and Scala 2.12/2.13, and the addition of ASF governance files (.asf.yaml, LICENSE, NOTICE). The Travis CI configuration has been updated to run tests against Spark 3.x with Scala 2.12, and various build artifacts and configuration files have been added or removed to support the new standalone build process.

(repo-wide) · high confidence

Core refactoring and new utility support for session kinds and line endings

The core library has been refactored to support new session types and improve cross-platform compatibility. A new \Kind\ enumeration defines session types including \shared\ and \sql\ alongside existing ones, with Jackson serialization support for API compatibility. A new \EOLUtils\ helper enables detection and conversion of Windows, Unix, and Old Mac line endings, addressing issues with interpreters like SparkR on Windows. Additionally, the \Utils\ object now includes a \createSecret\ method for generating Base64-encoded secure random strings, and the \Logging\ trait has been updated with explicit return types and improved error handling.

core/src/main/scala · high confidence

Introduction of RSC utility functions and package reorganization

The RSC module now includes a new Utils class providing standard validation checks (checkArgument, checkState, checkNotNull), thread factory creation, string joining, and exception handling utilities, reducing the need for external dependencies like Guava. Additionally, the code package has been renamed to org.apache.livy to align with the broader project structure.

livy-rsc · medium confidence

Livy server introduces access control, security headers, and API versioning

The Livy server now enforces role-based access control (view, modify, super) via a new AccessFilter and AccessManager, configurable through ACL settings. It also adds security-related HTTP headers (e.g., X-Content-Type-Options, X-Frame-Options) via a SecurityHeadersFilter, and supports API versioning through the Accept header to allow clients to target specific API versions. Additionally, the server now rejects session creation requests when the number of concurrent creations exceeds the configured limit, and session metrics are exposed as Codahale gauges for monitoring.

server/src/main/scala/org/apache/livy/server · high confidence

Livy server script rewritten with new lifecycle commands and Java 17 support

The bin/livy-server script has been completely rewritten to support start, stop, and status commands, replacing the previous direct-execution model. This change introduces configurable environment variables (such as LIVY\_PID\_DIR and LIVY\_LOG\_DIR), log rotation, and proper process management via PID files. Additionally, the script now includes specific JVM flags (--add-opens and --add-exports) required for Java 17 compatibility. Several legacy helper scripts (livy-repl, livy-yarn-client, livy-yarn-server, setup-classpath) have been removed as their functionality is either deprecated or integrated into the new server structure.

bin · high confidence

Refactor of Livy utility classes and support for Spark 3.0–4.2

This change refactors the core utility classes in the Livy server, moving them from the legacy com.cloudera.hue.livy package to org.apache.livy.utils and updating the license headers to the Apache Software Foundation. It introduces a new Clock abstraction to mock time for testing, adds a LivyUncaughtException class, and updates LivySparkUtils to support Spark versions 3.0 through 4.2 (with Scala 2.12/2.13 mappings). The SparkApp, SparkYarnApp, and SparkKubernetesApp utilities are enhanced with improved state tracking, namespace resolution for Kubernetes, and better handling of leaked applications. Additionally, LineBufferedProcess and LineBufferedStream are modified to use a circular queue for log buffering with configurable size, and SparkProcessBuilder is simplified to remove user-configurable path restrictions and support verbose output.

server/src/main/scala/org/apache/livy/utils · high confidence

Repl module refactored and migrated to Apache Livy namespace

The REPL source files have been moved from the Cloudera Hue project structure to the Apache Livy project, updating the package from com.cloudera.hue.livy to org.apache.livy. This migration includes renaming the source directory, updating copyright headers, and refactoring internal classes such as ProcessInterpreter to align with the new namespace and base classes.

repl/src/main/scala · high confidence

Standardized configuration management with new template files

The configuration directory has been reorganized to use a consistent template-based approach. New template files have been introduced for the client configuration (livy-client.conf.template), environment variables (livy-env.sh.template), server settings (livy.conf.template), logging (log4j2.properties.template), and Spark property blacklisting (spark-blacklist.conf.template). To support this structure, the previous livy-defaults.conf.template and spark-user-configurable-options.template files have been removed, consolidating configuration definitions into the new templates.

conf · high confidence

Updated PySpark interpreter resources for Python 3 compatibility and shared job support

The PySpark interpreter resources in the REPL module have been updated to support Python 3 (including versions \>= 3.8) by replacing Python 2-specific constructs like \cStringIO\ and \unicode\ with their Python 3 equivalents (\io\ and \str\). Additionally, the \fake\_shell.py\ script now includes logic to handle shared variables across jobs via a new \JobContextImpl\ class and supports executing bypass jobs through \PySparkJobProcessorImpl\, enabling better integration with Livy's job API and shared state management.

repl/src/main/resources · high confidence

Web UI updated to Bootstrap 4.6.2

The Livy Web UI's styling has been upgraded from Bootstrap 3 to version 4.6.2. This change updates the underlying CSS framework used for the interface, which may result in visual adjustments to layout, components, and responsiveness across the UI pages.

server/src/main/resources/org/apache/livy/server/ui/static/css · high confidence

Fixes

Added build.marker file

A new empty build.marker file has been added to the core resources directory, likely serving as a placeholder or marker for build processes.

core/src/main/resources · low confidence

Test coverage

Added Log4j2 test configuration files for client-http, rsc, and thriftserver modules; Added REPL test suite and migrated test package to Apache namespace; Added Scala API client and job handle tests; Added fake spark-submit script for test environments; Added integration test resources for PySpark, SparkR, and secure cluster validation; Added integration tests for batch, interactive, and job APIs; Added server-side unit tests for access control, API versioning, JSON serialization, session metrics, and security headers; Added test for RSCDriver cancel job failure during shutdown; Added test job utilities to livy-test-lib; Added test library with reusable test jobs and utilities; Added test resource configurations for logging and Spark settings; Added test suite for interactive session servlets and heartbeat logic; Added tests for LivyClientBuilder and test infrastructure; Added tests for Thrift Server session and column buffer operations; Added tests for ThriftServer LDAP authentication; Added tests for ThriftServer connection limits and data type handling; Added tests for the Python Livy client API; Added unit tests for EOL handling and a base test suite trait; Added unit tests for HTTP client and connection handling; Added unit tests for LDAP authentication handler; Added unit tests for Livy Spark utilities and app integrations; Added unit tests for Livy recovery state stores; Added unit tests for RSC driver address resolution and job handle state management; Added unit tests for batch session servlet and request handling; Added unit tests for session management and configuration validation; New integration test framework for external clusters and ThriftServer JDBC.

Dependencies

Initial Maven module structure and dependency definitions for Livy 1.0.0

The project now includes a complete set of Maven POM files defining the module hierarchy for version 1.0.0-SNAPSHOT. This change introduces the \livy-api\ module, which exposes Spark dependencies (core, hive, sql, streaming) as provided, and the \livy-rsc\ module, which depends on the API. The \livy-client-http\ module is defined with an HTTP client implementation using Apache HttpClient and Jackson, configured to shade internal dependencies like Kryo and Jackson to avoid conflicts. The \livy-core\ module is split into Scala 2.12 and 2.13 variants, both depending on the parent core module which includes Log4j2 and Jackson. The \livy-repl\ module is also split by Scala version, depending on the RSC and core modules. Additionally, the \livy-assembly\ module is introduced to package the server components, and the \livy-integration-test\ module is defined with dependencies on Hadoop, Spark, and Jackson for testing. The \docs\ directory now includes a Gemfile for Jekyll-based documentation generation.

(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

Score

  • CAI 47 → 49 (+2.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 42 → 42 (-0.0)
  • Architecture 98 → 98 (+0.0)
  • Maturity 54 → 54 (+0.0)
  • Readiness 59 → 58 (-1.1)
  • Security 52 → 54 (+1.4)
  • Accessibility 42 → 49 (+6.9)
  • Performance 82 → 100 (+18.3)

Resolved (70)

  • Critical CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • Critical CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • Critical CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • Critical CVE: [GHSA redacted] (api/pom.xml)
  • Critical CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • Critical CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • Critical CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • Critical CVE: [GHSA redacted] (api/pom.xml)
  • Duplicated block (14 lines × 2) (thriftserver/server/src/main/scala/org/apache/livy/thriftserver/LivyThriftSessionManager.scala)
  • FileTooLong: js/bootstrap.js (docs/assets/themes/apache/bootstrap/js/bootstrap.js)
  • High CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • High CVE: [GHSA redacted] (api/pom.xml)
  • High CVE: [GHSA redacted] (api/pom.xml)
  • High CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • High CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • High CVE: [GHSA redacted] (api/pom.xml)
  • High CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • High CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • High CVE: [GHSA redacted] (thriftserver/client/pom.xml)
  • High CVE: [GHSA redacted] (api/pom.xml)
  • …and 50 more

New (37)

  • Edited copies of one member (3 members, 17+ corresponding lines) (thriftserver/server/src/main/scala/org/apache/livy/thriftserver/cli/ThriftCLIService.scala)
  • Edited copies of one member (4 members, 16+ corresponding lines) (thriftserver/server/src/main/scala/org/apache/livy/thriftserver/operation/GetColumnsOperation.scala)
  • Edited copies of one member (7 members, 13+ corresponding lines) (thriftserver/server/src/main/scala/org/apache/livy/thriftserver/cli/ThriftCLIService.scala)
  • Edited copy of a member (12 corresponding lines) (rsc/src/main/java/org/apache/livy/rsc/rpc/Rpc.java)
  • Edited copy of a member (12 corresponding lines) (thriftserver/server/src/main/scala/org/apache/livy/thriftserver/cli/ThriftBinaryCLIService.scala)
  • Edited copy of a member (15 corresponding lines) (repl/src/main/scala/org/apache/livy/repl/ReplDriver.scala)
  • Edited copy of a member (17 corresponding lines) (server/src/main/scala/org/apache/livy/server/batch/CreateBatchRequest.scala)
  • Edited copy of a member (4 corresponding lines) (server/src/main/scala/org/apache/livy/utils/SparkKubernetesApp.scala)
  • High CVE: [GHSA redacted] (client-http/pom.xml)
  • High CVE: [GHSA redacted] (core/pom.xml)
  • High CVE: [GHSA redacted] (core/scala-2.12/pom.xml)
  • High CVE: [GHSA redacted] (core/scala-2.13/pom.xml)
  • High CVE: [GHSA redacted] (repl/pom.xml)
  • High CVE: [GHSA redacted] (repl/scala-2.12/pom.xml)
  • High CVE: [GHSA redacted] (repl/scala-2.13/pom.xml)
  • High CVE: [GHSA redacted] (server/pom.xml)
  • High CVE: [GHSA redacted] (client-common/pom.xml)
  • High CVE: [GHSA redacted] (client-http/pom.xml)
  • High CVE: [GHSA redacted] (core/pom.xml)
  • High CVE: [GHSA redacted] (core/scala-2.12/pom.xml)
  • …and 17 more

Architecture

  • Unchanged — 0 containers · 5 contexts · 1 edges

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

Survey your own repository

apache/livy 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 14 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 bc234453011e55138767f1b0ad3de9d4f77f93e8 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-e1a3b69fc8ee.