etcd-io/etcd
65.4
Adequate · 13 November 2026
77.7k
lines of production code
Go
primary language
6
measurements over time
What this system is
Features
Add CPU utility package for endianness detection
A new \pkg/cpuutil\ package has been introduced to provide facilities for detecting CPU-specific features. This update includes a \ByteOrder\ function that returns the byte order (BigEndian or LittleEndian) corresponding to the CPU's native endianness, leveraging the \golang.org/x/sys/cpu\ library.
pkg/cpuutil · high confidence
Add CRC-32 utility package with incremental checksum support
The \pkg/crc\ package introduces a new utility for computing CRC-32 checksums that supports incremental updates via an initial CRC value. This allows users to continue a checksum calculation from a previous state, matching the behavior of the standard library's \hash.Hash32\ interface while enabling stateful hashing workflows.
pkg/crc · high confidence
Add FIFO job scheduler package
The new \pkg/schedule\ package introduces a First-In-First-Out (FIFO) scheduler for executing units of work sequentially. Users can create jobs using \NewJob\ and schedule them via \NewFIFOScheduler\, which ensures jobs run in order and provides methods to track pending, scheduled, and finished counts, as well as waiting for completion. The implementation includes a \WaitFinish\ mechanism and handles job panics gracefully, ensuring the scheduler remains stable even if individual jobs fail.
pkg/schedule · high confidence
Add Interval Tree abstract data type
The \pkg/adt\ package now includes a new \IntervalTree\ implementation based on a red-black tree, supporting insertion, deletion, and stabbing queries (finding intervals that contain a specific point). The API is exposed via the \adt\ package, with example usage demonstrating how to insert intervals and query for overlaps.
pkg/adt · high confidence
Add YAML-based client configuration loader
Users can now load clientv3 configuration from a YAML file using the new \NewConfig\ function in the \client/v3/yaml\ package. This feature parses YAML settings for endpoints, TLS certificates, and CA files, automatically applying them to the client configuration, including enforcing TLS 1.2 as the minimum version.
client/v3/yaml · high confidence
Add client-side ordering violation detection for etcd v3
The \client/v3/ordering\ package introduces a wrapper that caches response header revisions to detect and handle ordering violations caused by stale responses (e.g., when reconnecting to a partitioned member). Users can wrap their \clientv3.KV\ with \ordering.NewKV\ and provide a custom violation handler; the package also includes a default \NewOrderViolationSwitchEndpointClosure\ that automatically switches endpoints after repeated violations to ensure data consistency.
client/v3/ordering · high confidence
Add etcd Grafana dashboard mixin with Grafana 7.x support and database fragmentation metrics
The etcd dashboard mixin now includes a new \etcd-grafana7x.libsonnet\ file that provides a dashboard compatible with Grafana 7.x, enabled via the \grafana7x=true\ configuration option. The default dashboard (for newer Grafana versions) has been updated to include the \dbSizeInUse\ metric, allowing users to visualize the database fragmentation ratio alongside the total database size. Additionally, the Grafana 7.x dashboard variant includes an etcd selector for more precise cluster targeting.
contrib/mixin/dashboards · high confidence
Add lock storage example service
Introduces a new HTTP-based storage example in contrib/lock/storage that implements a simple key-value store with optimistic concurrency control. The service listens on port 8080 and supports 'read' and 'write' operations via JSON requests, returning version mismatches on concurrent write attempts. It includes a .gitignore file to exclude the 'storage' directory.
contrib/lock/storage · high confidence
Add mock storage recorder for testing
The server/mock/mockstorage package now includes a StorageRecorder that implements the etcdserver storage interface, allowing tests to record and verify storage operations such as Save, SaveSnap, Release, and Sync without performing actual I/O.
server/mock/mockstorage · high confidence
Add mutex profiling to debug utilities
The debugutil package now exposes a comprehensive set of pprof HTTP handlers under the /debug/pprof prefix, including support for mutex profiling. This enables users to diagnose contention issues by accessing the new /debug/pprof/mutex endpoint, alongside existing endpoints for heap, goroutine, block, and trace profiling.
pkg/debugutil · high confidence
Add proto-annotation tool to dump etcd\_version annotations
A new command-line tool (\proto-annotation\) is introduced in the \tools/proto-annotations/cmd\ package to extract and print specific proto annotations (currently \etcd\_version\) from all protobuf definitions used by etcd. The tool scans protobuf files, validates version constraints (e.g., major version non-zero, patch zero), and outputs the results to stdout, aiding in the verification that new proto definitions include the required version annotations.
tools/proto-annotations/cmd · high confidence
Add string utility functions for generating random strings
The pkg/stringutil package now includes functions to generate random strings. Users can call UniqueStrings to get a slice of distinct random strings or RandomStrings for a slice that may contain duplicates. These utilities are implemented using the standard math/rand package and are accompanied by tests to verify the uniqueness property of the generated strings.
pkg/stringutil · high confidence
Add systemd unit files and documentation for deploying etcd
This change introduces official systemd support for running etcd, providing a ready-to-use service unit file for single-node deployments and a comprehensive README with configuration examples for multi-node clusters. It also includes a sysusers configuration file to automatically create the 'etcd' system user and group, simplifying the setup process for users managing etcd via systemd.
contrib/systemd · high confidence
Add testgrid-analysis tool to detect flaky tests
A new CLI tool, testgrid-analysis, has been added to the tools directory to analyze test results from the sig-etcd-periodics dashboard. The tool provides a 'flaky' command that queries the TestGrid API to identify tests with failure rates exceeding a configurable threshold (default 10%) over a specified number of runs. It can optionally create GitHub issues for detected flaky tests, including failure logs and links to the relevant TestGrid tabs, to help developers track and resolve intermittent failures.
tools/testgrid-analysis · high confidence
Add userspace TCP proxy for routing client connections
A new OSI layer 4 TCP proxy has been added to the server package, allowing etcd clients to be routed to backend servers via SRV records. The proxy implements weighted round-robin load balancing based on SRV priority and weight, monitors endpoint health by attempting TCP connections, and automatically deactivates unreachable backends. This change introduces the \server/proxy/tcpproxy\ package with its implementation and associated tests.
server/proxy/tcpproxy · high confidence
Add v2 in-memory key/value store implementation and tests
The v2 API's in-memory key/value store implementation is added to the \server/etcdserver/api/v2store\ package, including core components for node management, event history, and metrics, along with comprehensive unit and benchmark tests to validate store operations and performance.
server/etcdserver/api/v2store · high confidence
Add version annotation extensions to protobuf definitions
The API now includes new protobuf extensions (etcd\_version\_msg, etcd\_version\_field, etcd\_version\_enum, etcd\_version\_enum\_value) that allow marking messages, fields, enums, and enum values with the etcd version that introduced them. This enables the system to detect the minimum etcd version required to interpret WAL data containing these elements, improving version compatibility checks.
api/versionpb · high confidence
Added etcd distributed locking example with fencing
A new Go example application has been added to the contrib/lock/client directory that demonstrates distributed locking with fencing using the etcd client/v3 concurrency package. The application acquires a lock via an etcd session and lease, then attempts to write to a local HTTP storage endpoint, illustrating how to prevent stale writes by validating the lease version before committing data.
contrib/lock/client · high confidence
Added file descriptor usage and limit monitoring on Linux
The runtime package now exposes functions to query the current file descriptor limit and usage count on Linux systems. The new \fds\_linux.go\ implementation retrieves the soft limit via \syscall.Getrlimit\ and counts open file descriptors by reading the \/proc/self/fd\ directory, while \fds\_other.go\ provides stubs that return errors on non-Linux platforms. This enables the system to monitor and report on file descriptor consumption.
pkg/runtime · high confidence
Added local etcd cluster discovery script for testing
A new \hack/insta-discovery\ directory has been introduced to facilitate local testing of etcd clusters using the discovery service. This includes a shell script that provisions a new discovery endpoint, a Procfile to manage four local etcd nodes (named infra1 through infra4) with distinct client and peer ports, and documentation explaining the setup.
hack/insta-discovery · high confidence
Added user\_add.sh script for creating users via the gRPC Gateway
A new shell script, user\_add.sh, has been added to the client/v3/experimental/recipes/grpc\_gateway directory. This script allows users to create new etcd users by interacting with the gRPC Gateway API. It handles authentication token generation and user creation via curl, requiring the user to provide a username and password at runtime. The script is configured with default connection details (localhost:2379) and expects TLS certificates to be specified in the script variables.
_client/v3/experimental/recipes/grpc\gateway · high confidence
Document etcd-backed gRPC naming and resolver usage
The client/v3/naming package now includes documentation explaining how to use the endpoints and resolver subpackages to discover gRPC services via etcd. Users can register, read, and delete endpoint addresses, and configure gRPC clients to use the etcd resolver for service discovery, including support for expiring endpoints via leases.
client/v3/naming · high confidence
Embed server refactored with distributed tracing and logging improvements
The embed server package has been restructured to support new operational capabilities. It now includes built-in distributed tracing via OpenTelemetry, allowing users to configure a collector address, service name, instance ID, and sampling rate through the \config\_tracing.go\ module. Logging has been enhanced with configurable output paths, log rotation support via \config\_logging.go\, and improved TLS handshake error logging. Additionally, the server now exposes socket options (reuse-port, reuse-address) and enforces stricter client TLS requirements for secure metrics URLs.
server/embed · high confidence
Establishes etcd security reporting and release processes
Introduces a formal security response framework for the etcd project, including a dedicated Product Security Committee (PSC) to handle vulnerability triage, patching, and disclosure. Users can now report vulnerabilities via a GitHub security advisory form, with clear guidelines on response timelines (acknowledgment within 5 days, disclosure typically within 1-3 weeks) and communication channels (etcd-dev mailing list). The change also provides email templates for security announcements and defines the internal workflow for the PSC, including member responsibilities and retrospective processes.
security · high confidence
Experimental distributed synchronization recipes added to client/v3
The \client/v3/experimental/recipes\ package now provides a set of client-side distributed synchronization primitives, including a Barrier, DoubleBarrier, RWMutex, Queue, and PriorityQueue. These recipes allow applications to coordinate across multiple processes using etcd keys and leases, offering features such as blocking until a key is deleted (Barrier), coordinating entry and exit for a fixed number of processes (DoubleBarrier), managing read/write locks (RWMutex), and implementing FIFO or priority-based queues (Queue, PriorityQueue).
client/v3/experimental/recipes · high confidence
Experimental etcd client cache library added
A new \cache\ package has been introduced to provide an experimental client-side caching layer for etcd. This library buffers a single upstream etcd Watch for a specified key-prefix and fans out events to multiple local watchers, supporting features like history replay for lagging watchers, progress notifications, and configurable B-tree storage. It is designed to reduce upstream watch load and improve client responsiveness, though it currently does not support gRPC proxies.
cache · high confidence
Initial etcd alerting rules and configuration support
Adds the \contrib/mixin/alerts/alerts.libsonnet\ file, introducing a comprehensive set of Prometheus alerting rules for etcd monitoring. This includes alerts for member availability (\etcdMembersDown\), leader election stability, gRPC request health, and disk performance metrics. The rules are configurable via selectors and instance labels, allowing users to integrate these specific etcd health checks into their monitoring stack.
contrib/mixin/alerts · high confidence
Initial project scaffolding and configuration
The repository is initialized with essential project infrastructure files, including a .gitignore to exclude build artifacts and IDE files, a .go-version file specifying Go 1.27.1 as the required toolchain, and a .header file for standard Apache 2.0 license boilerplate. Additionally, a Dockerfile is added to containerize the etcd binary using a distroless base image, and governance documents (GOVERNANCE.md, ADOPTERS.md, CONTRIBUTING.md, DCO) are introduced to define community standards, production usage, and contribution workflows.
(repo-wide) · high confidence
Introduce Go-based rw-heatmaps tool for mixed read/write performance visualization
The mixed read/write performance evaluation tool in tools/rw-heatmaps has been reimplemented in Go, replacing the previous implementation. This new version provides a CLI utility that reads benchmark CSV data and generates visual performance charts, supporting both heatmap grids and line charts. Users can now generate read/write heatmaps to visualize performance across different connection counts and value sizes, or produce line charts to compare QPS trends. The tool allows comparing two benchmark runs to highlight performance differences and supports output in multiple image formats (JPG, PNG, TIFF).
tools/rw-heatmaps · high confidence
Introduce Kubernetes KV interface to etcd client
Added a new \client/v3/kubernetes\ package that provides a Kubernetes-specific key-value interface for the etcd client. This includes an \Interface\ definition and a concrete \Client\ implementation supporting \Get\, \List\, \Count\, \OptimisticPut\, and \OptimisticDelete\ operations, allowing Kubernetes components to interact with etcd using semantics adjusted for their needs.
client/v3/kubernetes · high confidence
Introduce alpha Prometheus monitoring mixin for etcd
Adds a new, customizable set of Prometheus alerts and Grafana dashboards for monitoring etcd clusters, located in contrib/mixin. The mixin provides out-of-the-box alerting for critical cluster states such as insufficient members, high leader change rates, excessive database growth, and high fragmentation, along with dashboards for peer round-trip times and gRPC metrics. It supports configuration via a cluster label selector, allows generation of Grafana 7.x-compatible dashboards via a config flag, and includes a test suite to validate alert rules.
contrib/mixin · high confidence
Introduce etcd-dump-db diagnostic tool
A new command-line utility, etcd-dump-db, is available to inspect etcd database files. It provides commands to list buckets, compute database hashes, and iterate through key-value pairs with optional Protocol Buffer decoding for structured data (keys, leases, auth, meta). A new scan-keys command allows scanning the key space starting from a specific revision, which is useful for recovering data even from corrupted databases.
tools/etcd-dump-db · high confidence
Introduce etcd-dump-metrics tool for automated metrics documentation
A new command-line utility, etcd-dump-metrics, is available to automate the generation of Prometheus metrics documentation. The tool can fetch metrics from a running etcd instance via a specified address, or automatically download a specific etcd release binary (for Linux and macOS) to spin up a local 2-node cluster and extract metrics from it. It outputs a sorted, human-readable list of metrics, including descriptions, types, and aggregated gRPC codes, making it easier to track and document the observability surface of etcd versions.
tools/etcd-dump-metrics · high confidence
Introduce etcdutl as a dedicated file-surgery utility
A new \etcdutl\ command-line tool is introduced to handle direct operations on etcd data files, separating these 'surgery' tasks from network-based commands in \etcdctl\. This utility includes commands for defragmenting data directories, restoring snapshots, checking snapshot and hash status, migrating data, and generating shell completions, along with a global timeout flag for file locking.
etcdutl · high confidence
Introduce gRPC proxy Range response caching
The gRPC proxy now caches Range responses to reduce backend load. This new cache implementation, located in server/proxy/grpcproxy/cache, stores responses in an LRU structure (using k8s.io/utils/lru) and maintains an interval tree for efficient invalidation when keys are modified or the backend is compacted. Users will see improved performance for repeated Range requests within the cache window.
server/proxy/grpcproxy/cache · high confidence
Introduce in-process gRPC server-to-client adapters for the proxy
The gRPC proxy adapter layer now includes a new set of client adapters that allow the proxy to invoke local server implementations directly, bypassing the network stack. This change introduces a generic channel-based streaming mechanism (chan\_stream) to handle bidirectional and server-streaming RPCs in-memory, and provides specific adapters for Auth, Cluster, Election, Lease, Lock, Maintenance, and Watch services. This enables the proxy to forward requests to the local etcd server instance without requiring a separate gRPC connection, simplifying the internal communication path.
server/proxy/grpcproxy/adapter · high confidence
Introduce local-tester network bridge with fault injection capabilities
Added a new network bridge tool in tools/local-tester/bridge that allows simulating various network failure conditions for testing purposes. The bridge supports packet corruption, reordering, transmission/reception delays, blackholing, and random connection termination. This tool is now deprecated in favor of the etcd robustness testing suite.
tools/local-tester/bridge · high confidence
Introduce official etcd benchmarking tool
A new benchmarking tool for etcd clusters has been added under tools/benchmark. Users can now install the tool via 'go install ./tools/benchmark' or run it directly with 'go run ./tools/benchmark' to measure etcd v3 API performance, with usage details available in the new README.
tools/benchmark · high confidence
Introduce pkg/expect for PTY-based process testing
The new \pkg/expect\ package provides an expect-style interface for testing processes that run over a pseudo-terminal (PTY). It allows users to spawn external commands, capture their output line-by-line, and match responses using either exact strings or regular expressions via \ExpectedResponse\. The package supports interactive input through \Send\ and \SendLine\, process lifecycle management with \Stop\ and \Close\, and signal handling via \Signal\. It also exposes process exit codes and errors, enabling robust verification of command behavior in tests.
pkg/expect · high confidence
Introduce pkg/wait utility for ID-based and logical-deadline event waiting
The new pkg/wait package provides two mechanisms for coordinating asynchronous events. The Wait interface allows components to register for notifications by a unique ID, receiving a channel that is triggered when another part of the system calls Trigger with that same ID, with duplicate registrations causing a panic. Additionally, the WaitTime interface supports logical deadlines, where waiting on a deadline is satisfied when a later or equal deadline is triggered, allowing multiple waiters to be notified in a single broadcast. Both implementations are designed for high concurrency, using sharded locks for ID-based waits and a simple mutex for deadline-based waits.
pkg/wait · high confidence
Introduce proto-annotations CLI tool
A new command-line tool located at tools/proto-annotations has been added to the codebase. This utility serves as the entry point for processing protocol buffer annotations, enabling static validation and documentation improvements for etcd version metadata within the protobuf definitions.
tools/proto-annotations · high confidence
Introduce traceutil package for structured request tracing
The new \pkg/traceutil\ package provides utilities for tracing etcd operations, integrating with OpenTelemetry for distributed tracing and using Zap for structured logging. It allows callers to record detailed steps and fields for operations like range, transaction, and compaction requests, enabling better observability and debugging of request latency and internal processing stages.
pkg/traceutil · high confidence
Introduce v2 stats package for cluster leader and server metrics
The server/etcdserver/api/v2stats package has been added to provide structured statistics for etcd cluster operations. LeaderStats now tracks per-follower latency (current, average, standard deviation, min/max) and request success/failure counts, while ServerStats exposes node state, leader information, and aggregate send/receive append request rates and bandwidth. These stats are exposed via JSON serialization for monitoring and debugging purposes.
server/etcdserver/api/v2stats · high confidence
Introduce v3-based cluster discovery service
Adds a new v3 discovery implementation in the \server/etcdserver/api/v3discovery\ package, enabling etcd nodes to bootstrap and join clusters using the v3 client API. The \DiscoveryConfig\ struct now embeds \clientv3.ConfigSpec\ (renamed from \ClientConfig\) to leverage the shared client configuration, and the service uses the \/\_etcd/registry\ key prefix to manage cluster membership and size via the v3 KV store.
server/etcdserver/api/v3discovery · high confidence
Introduction of dedicated etcdserver error definitions
The server now exposes a dedicated set of error variables (such as ErrUnknownMethod, ErrStopped, ErrCanceled, and ErrTimeout) within the server/etcdserver/errors package, along with a DiscoveryError type. This provides a standardized, typed way for users and internal components to detect and handle specific etcd server conditions rather than relying on generic or string-matched errors.
server/etcdserver/errors · high confidence
Introduction of thread-safe event notification mechanism
A new \Notifier\ struct has been added to the \pkg/notify\ package, providing a thread-safe way to broadcast events to multiple consumers. Users can now utilize this component to wait for notifications via a channel and trigger updates by closing the current channel and creating a new one, ensuring safe concurrent access through internal read-write locking.
pkg/notify · high confidence
Introduction of v3 Election and Lock server implementations
The server now includes the v3 Election and Lock API service implementations in the \server/etcdserver/api/v3election\ and \server/etcdserver/api/v3lock\ packages. These new components expose distributed election and locking capabilities via the gRPC v3 API, utilizing the underlying concurrency primitives and lease management to handle leader election, proclamation, observation, and mutex locking for clients.
server/etcdserver/api/v3election, server/etcdserver/api/v3lock · high confidence
Namespace support for etcd client operations
The client/v3/namespace package now provides wrappers for KV, Watcher, and Lease interfaces that automatically prefix all keys with a specified string. This allows applications to isolate data by namespace without modifying application logic; for example, calling cli.Put("abc", "123") will store the value under "my-prefix/abc" in etcd, while responses automatically have the prefix stripped so the application sees "abc". Transaction operations are also supported, with comparison and operation keys prefixed accordingly.
client/v3/namespace · high confidence
New DNS SRV record lookup package for client discovery
A new \client/pkg/srv\ package has been added to handle DNS SRV record lookups for etcd client discovery. This package provides functions to resolve cluster members and client endpoints via DNS, including logic to handle trailing dots in SRV targets and scheme mismatches between advertised URLs and DNS records. The addition includes comprehensive unit tests to verify correct behavior for both SSL and non-SSL service discovery.
client/pkg/srv · high confidence
New HTTP handlers for lease renewals and time-to-live queries
The server now exposes dedicated HTTP endpoints for lease management: the public \/leases\ path handles lease renewals (KeepAlive), and the internal \/leases/internal\ path handles time-to-live lookups. These handlers enforce a 64 KB request body limit to prevent unbounded memory usage, wait for the node's applied index to catch up before processing, and return specific HTTP status codes (e.g., 413 for oversized bodies, 408 for timeouts, 404 for missing leases) to provide clear feedback to clients. The implementation includes corresponding unit tests for successful operations and timeout scenarios.
server/lease/leasehttp · high confidence
New HTTP utility functions for graceful response closing and hostname extraction
The pkg/httputil package now includes two new utility functions: GracefulClose, which drains and closes HTTP response bodies to allow TCP/TLS connection reuse, and GetHostname, which safely extracts the hostname from an HTTP request's Host field, handling edge cases like invalid port separators. These additions provide reusable helpers for managing HTTP resources and parsing request metadata.
pkg/httputil · high confidence
New I/O utility types and functions in pkg/ioutil
The pkg/ioutil package now includes several new capabilities: a PageWriter that buffers writes to ensure data is flushed to the underlying writer in page-aligned chunks (configurable via pageBytes and pageOffset), an ExactReadCloser that validates reads match an expected byte count and returns specific errors for short reads or unexpected EOF, a LimitedBufferReader that caps the number of bytes returned per Read call, and a WriteAndSyncFile function that writes data to a file and explicitly syncs it to disk before closing to guarantee persistence.
pkg/ioutil · high confidence
New TLS setup example using cfssl
Added a new example in the hack/tls-setup directory that demonstrates how to generate TLS certificates for an etcd cluster using Cloudflare's cfssl tool. The example includes a Makefile to automate certificate generation (CA, server, and peer certs), a Procfile to run a three-node cluster with a proxy using goreman, and a README with instructions for configuring IP addresses and running the setup.
hack/tls-setup · high confidence
New benchmark report package with JSON output and weighted statistics
The \pkg/report\ package now provides a structured way to generate benchmark reports, including a new JSON format compatible with Perfdash that exposes 50th, 90th, and 99.9th percentile latencies. Users can also access raw statistical data via a new \Stats\ interface and utilize \NewWeightedReport\ to account for request weights in performance calculations.
pkg/report · high confidence
New client-side leasing layer for linearizable reads
The \client/v3/leasing\ package introduces a new leasing protocol that serves linearizable reads from a local cache by acquiring exclusive write access to keys. This allows multiple clients to perform writes while ensuring that subsequent reads are served locally for the lease's lifetime, improving performance and reducing server load. The implementation includes a \leaseCache\ for managing key revisions and revocations, a \leasingKV\ wrapper that intercepts Get, Put, Delete, and Txn operations to enforce the leasing logic, and support for transactional comparisons and range operations within the lease context.
client/v3/leasing · high confidence
New client/v3/naming/endpoints API for endpoint management
The client/v3/naming/endpoints package introduces a new API for managing service endpoints in etcd, providing an Endpoint struct with Addr and Metadata fields, and a Manager interface that supports atomic updates, individual add/delete operations, listing, and watching for changes. The implementation uses a JSON-based internal format for persistence, compatible with gRPC naming conventions, and includes a NewManager constructor to initialize the manager with an etcd client and target.
client/v3/naming/endpoints · high confidence
New cobrautl package for shared CLI utilities
A new \pkg/cobrautl\ package has been introduced to centralize common command-line interface utilities previously scattered across etcdctl v2 and v3. This package provides standardized error handling via \ExitWithError\ and consistent help output formatting through a custom \UsageFunc\ and template-based help system. Users benefit from unified CLI behavior and error codes across etcdctl versions, as these shared utilities are now maintained in a single location.
pkg/cobrautl · high confidence
New command output normalizer for consistent etcdctl formatting
A new \Normalize\ function has been added to the \etcdctl/util\ package to standardize the formatting of command output. This utility trims leading and trailing whitespace and applies a two-space indentation to each line, ensuring consistent and readable display of multi-line results in the etcdctl tool.
etcdctl/util · high confidence
New contention detection package for monitoring routine starvation
Added a new \pkg/contention\ package that provides a \TimeoutDetector\ to identify system contention by observing the time elapsed between successive events. This utility allows the system to detect when operations exceed expected durations, helping to surface routine starvation issues.
pkg/contention · high confidence
New credentials package for gRPC authentication in client/v3
A new \client/v3/credentials\ package has been introduced to manage gRPC credentials for the etcd client. This package provides \NewTransportCredential\ for TLS configuration and a \PerRPCCredentialsBundle\ that allows users to dynamically update authentication tokens via \UpdateAuthToken\. The bundle implements the standard gRPC credential interfaces, ensuring that the current token is correctly included in request metadata, and includes unit tests to verify token update and retrieval behavior.
client/v3/credentials · high confidence
New data-directory consistency verification tool
A new \server/verify\ package has been added to analyze the persistent state of etcd and detect potential inconsistencies between the Write-Ahead Log (WAL) and the backend storage. This tool allows users to run verification checks on a data directory (typically when the node is not running) to ensure that the backend's consistent index and term match the WAL's committed state, helping to identify corruption or drift before starting the server.
server/verify · high confidence
New datadir package for etcd storage path resolution
A new \datadir\ package has been introduced in the storage layer to centralize the logic for constructing etcd data-directory paths. This change provides dedicated functions such as \ToBackendFileName\, \ToSnapDir\, \ToWalDir\, and \ToMemberDir\, allowing users and internal components to reliably resolve the file-system layout for member data, snapshots, and write-ahead logs. The package also includes a deprecated \ToWalDir\ function (lowercase 'l') to maintain backward compatibility with existing code while encouraging the use of the correctly named \ToWALDir\.
server/storage/datadir · high confidence
New etcd key-value state mirroring capability
The client/v3/mirror package now provides a Syncer interface that allows users to mirror the key-value state of an etcd cluster. This includes syncing the base state via SyncBase, which handles fetching the most recent revision if none is specified and paginating through keys, and syncing subsequent updates via SyncUpdates using a watch on the specified prefix.
client/v3/mirror · high confidence
New etcd-dump-logs tool for analyzing WAL logs
A new command-line utility, etcd-dump-logs, is introduced to help users inspect and analyze etcd Write-Ahead Log (WAL) data. The tool supports filtering entries by type (such as Normal, ConfigChange, and various Internal Raft Requests), specifying index ranges for targeted dumps, and outputting raw low-level log records. It also features a stream-decoder option for piping binary data through external decoding tools, providing a flexible way to debug and audit etcd server state.
tools/etcd-dump-logs · high confidence
New etcdutl snapshot management package
The \etcdutl/snapshot\ package has been introduced to handle v3 snapshot operations, providing a \Manager\ interface with \Save\, \Status\, and \Restore\ methods. The \Status\ command now reports detailed snapshot information including a file hash, revision, total unique user keys, total size, and the etcd version stored in the snapshot. This change reflects the architectural split of \etcdctl\ into \etcdctl\ (for public API access) and \etcdutl\ (for direct file surgery), moving snapshot utilities into the latter.
etcdutl/snapshot · high confidence
New flag value types and environment variable handling in pkg/flags
The pkg/flags package now provides a comprehensive set of new flag value types to improve command-line configuration: SelectiveStringValue and SelectiveStringsValue enforce that flag inputs are restricted to a predefined list of valid options; UniqueStringsValue and UniqueURLsValue deduplicate comma-separated inputs, with UniqueURLsValue also supporting specific exceptions; and a new uint32Value type handles unsigned 32-bit integers. Additionally, the package introduces SetFlagsFromEnv and SetPflagsFromEnv to automatically populate flags from environment variables (e.g., ETCD\_SOME\_FLAG), complete with logic to detect and warn about unrecognized or conflicting environment variables.
pkg/flags · high confidence
New gRPC proxy implementation for etcd v3 API
The \server/proxy/grpcproxy\ package now provides a complete, modular gRPC proxy for the etcd v3 API. This change introduces dedicated proxy implementations for all core services—Auth, Cluster, KV, Election, Lease, Lock, Maintenance, and Watch—along with supporting components for health checks, metrics, leader detection, and endpoint registration. The KV proxy includes a serializable read cache to reduce backend load, while the Watch proxy implements event coalescing to efficiently serve multiple client watchers. This new architecture replaces the previous proxy logic, offering a more robust and maintainable foundation for proxying etcd traffic.
server/proxy/grpcproxy · high confidence
New gRPC testing utilities for recording requests and stubbing servers
The \pkg/grpctesting\ package now includes \GRPCRecorder\ and \StubServer\ components to support gRPC testing. \GRPCRecorder\ provides a unary server interceptor that captures incoming request metadata (such as the full method and authority) for verification in tests. \StubServer\ offers a customizable, lightweight gRPC server implementation that can be started and stopped easily within test cases, including a built-in dummy service for simple unary call testing.
pkg/grpctesting · high confidence
New idutil package for generating unique identifiers
A new \pkg/idutil\ package has been added to provide utility functions for generating unique, randomized IDs. The \Generator\ struct creates identifiers by combining a member ID prefix, a timestamp, and an atomic counter, ensuring uniqueness across restarts and different nodes. The implementation uses atomic operations for the counter to reduce conflict rates and extends the event window to 2^48 by allowing the counter to overflow into the timestamp field.
pkg/idutil · high confidence
New mock packages for store and wait interfaces
Added the \server/mock/mockstore\ and \server/mock/mockwait\ packages, which provide mock implementations of the \v2store.Store\ and \wait.Wait\ interfaces respectively. These new utilities allow tests to record method calls and simulate store or wait behavior without performing actual operations, facilitating more isolated and predictable testing of server components that depend on these interfaces.
server/mock/mockstore · high confidence
New mock server implementation for etcd client v3
The client/v3/mock package now includes a new mock server implementation (mockserver) that provides a mocked-out gRPC server for the etcdserver interface. This allows developers to test client code against a simulated etcd server without needing a real etcd instance. The mock server supports both TCP and Unix socket networks, can start multiple servers, and implements basic KV operations (Range, Put, DeleteRange, Txn) and Lease operations. It also includes a mock KV server that returns empty responses for standard operations and explicitly marks RangeStream as unimplemented.
client/v3/mock · high confidence
New pbutil package for Protocol Buffer helpers
The pkg/pbutil package has been introduced to provide utility functions and interfaces for handling Protocol Buffer objects. It defines Marshaler and Unmarshaler interfaces and offers helper functions such as MustMarshal, MustUnmarshal, MaybeUnmarshal, MustMarshalMessage, MustUnmarshalMessage, GetBool, and Boolp to simplify common serialization and boolean-pointer operations. Tests have been added to verify the correct behavior of these utilities, including panic handling for error cases.
pkg/pbutil · high confidence
New proxy server for network fault simulation
Added a new proxy server implementation in pkg/proxy that simulates network faults such as latency spikes, packet drops, and corruption without requiring iptables or tc dependencies. The package exposes a Server interface allowing tests to control connection acceptance delays, transmit/receive latencies, and packet modification, with support for both TCP and Unix socket transports over insecure and TLS-secured connections.
pkg/proxy · high confidence
New scripts for benchmarking, release builds, and protobuf generation
The scripts directory now includes dedicated tooling for development workflows: \benchmark\_test.sh\ allows running benchmarks against a local etcd server, \build-binary.sh\ and \build-docker.sh\ handle building release binaries and multi-architecture Docker images, and \release.sh\ orchestrates the full release process including version bumping and tagging. Additionally, \genproto.sh\ has been consolidated to manage protobuf generation using protoc 3.20.3 and grpc-gateway v2, while \fuzzing.sh\ enables running fuzz tests on v3 RPC interfaces.
scripts · high confidence
New standalone scripts for fixing code quality and dependency issues
The scripts/fix directory now includes dedicated, standalone scripts to automatically correct common code quality and configuration issues. Users can now run specific fixers for generating the bill of materials (bom.sh), tidying Go module dependencies (mod-tidy.sh), correcting whitespace in Bash scripts (shell\_ws.sh), syncing Go toolchain directives across modules (sync\_go\_toolchain\_directive.sh), and fixing YAML linting issues (yamllint.sh). These scripts provide targeted, one-command solutions for maintaining repository hygiene without needing to invoke broader, monolithic tooling.
scripts/fix · high confidence
New tool to detect experimental gRPC API usage
A new \check-grpc-experimental\ tool has been added to the repository to scan code for usage of experimental gRPC APIs. The tool parses Go source files, identifies references to symbols from the \google.golang.org/grpc\ package, and checks their documentation for experimental markers. It supports an allowlist (provided via \allowlist.txt\) to permit specific APIs that are currently in use but not yet stabilized, helping maintain code quality by flagging reliance on unstable interfaces.
tools/check-grpc-experimental · high confidence
New types package in client/pkg/types
The \client/pkg/types\ package has been introduced to provide core data types and type-checking utilities for the client. This includes an \ID\ type for handling base-16 identifiers, \URLs\ and \URLsMap\ for parsing and managing cluster endpoint strings (now supporting \unix\ and \unixs\ schemes), a \Set\ interface with both thread-safe and unsafe implementations, and sortable slice types for IDs and uint64s.
client/pkg/types · high confidence
New v3client package for in-process server access
A new v3client package has been added to the server module, providing a way to wrap an in-process EtcdServer instance with a standard clientv3 interface. This allows applications to interact with the server directly via function calls rather than gRPC sockets, simplifying integration for embedded or internal use cases. The implementation maps server-side API handlers (KV, Lease, Watch, Maintenance, Cluster, Auth) to client-side interfaces using adapter functions, and includes a watch wrapper to prevent data races on trace context data.
server/etcdserver/api/v3client · high confidence
New v3compactor package for automated MVCC storage compaction
The \server/etcdserver/api/v3compactor\ package has been introduced to manage automated compaction of etcd's MVCC storage. It provides two distinct compaction modes: \periodic\, which purges old log data based on a configured time retention window (e.g., compacting every hour for a 24-hour retention), and \revision\, which purges revisions older than a specified count every 5 minutes. The package exposes a \Compactor\ interface with \Run\, \Stop\, \Pause\, and \Resume\ methods, allowing users to control the background compaction loop. This change implements the core logic for these automated policies, including handling compaction failures with retries and skipping compaction if the revision number has not changed.
server/etcdserver/api/v3compactor · high confidence
New verification framework with environment-controlled assertions
The client package now includes a new \verify\ package that provides a generic assertion mechanism controlled by the \ETCD\_VERIFY\ environment variable. Users can enable assertions via the \all\ or \assert\ values, allowing for runtime checks that panic on failure, which is primarily useful for testing and debugging rather than production stability.
client/pkg/verify · high confidence
Rewritten benchmark tool with new subcommands and clientv3 API
The benchmark utility in tools/benchmark/cmd has been completely rewritten to use the clientv3 API and Cobra CLI framework, replacing the previous implementation. It now provides a comprehensive set of subcommands for performance testing: 'put' and 'range' for basic key operations with options for rate limiting, consistency levels, and pagination; 'mvcc' for direct storage-level benchmarking; 'watch', 'watch-get', and 'watch-latency' for monitoring performance and contention; 'stm' for distributed transaction isolation testing; 'txn-put' and 'txn-mixed' for transaction workloads; and 'lease-keepalive' for lease management. The tool supports TLS, authentication, and multiple client connections.
tools/benchmark/cmd · high confidence
TLS utility package added with TLS 1.3 and cipher suite support
The client package now includes a new tlsutil library that provides utilities for handling TLS configurations. This addition introduces explicit support for TLS 1.3 via the GetTLSVersion function, allowing users to configure the minimum TLS version (TLS 1.2 or 1.3). It also adds cipher suite management through GetCipherSuite and GetCipherSuites, which map string names to their corresponding IDs, including support for legacy names like CHACHA20\_POLY1305. Existing certificate loading functionality (NewCertPool, NewCert) has been moved to this package and updated to use the modern os.ReadFile API instead of the deprecated io/ioutil.
client/pkg/tlsutil · high confidence
etcd Go client v3 is now a standalone module
The etcd Go client v3 has been extracted into its own independent module at \go.etcd.io/etcd/client/v3\. This change introduces a new \client/v3\ directory containing the full client implementation, including \auth.go\, \client.go\, and configuration files like \.gomodguard.yaml\ and \LICENSE\. The module enforces strict dependency boundaries to prevent circular dependencies on the server or internal packages, and provides updated documentation in \README.md\ for installation and usage.
client/v3 · high confidence
etcdutl CLI tool introduced for direct data directory surgery
The \etcdutl\ command-line utility is now available as a separate tool from \etcdctl\, designed for direct operations on etcd data files rather than live cluster access. It provides commands to migrate storage schemas (\migrate\), restore snapshots (\snapshot restore\) with optional revision bumping and compaction marking, check database status (\snapshot status\), compute key-value space hashes (\hashkv\), and defragment data directories (\defrag\). It also includes a \version\ command to display the tool's version and an \completion\ command to generate shell completion scripts for bash, zsh, fish, and powershell.
etcdutl/etcdutl · high confidence
Architecture
Centralized tool dependency management via tools/mod
The project introduces a dedicated \tools/mod\ directory to centralize and track development tool dependencies using the Go modules pattern. This change consolidates tools such as golangci-lint, protoc-gen-go, and various linters into a single module, ensuring they are explicitly pinned and preserved by \go mod tidy\. A new \install\_all.sh\ script allows users to install all listed tools in one step, simplifying the local development environment setup.
tools/mod · high confidence
Lease management code reorganized into the server/lease package
The lease management logic has been restructured into the server/lease package, consolidating the core lease structures, the lessor implementation, and the lease expiration queue into dedicated files (lease.go, lessor.go, lease\_queue.go). This change also introduces a new LeaseExpiredNotifier component to manage lease expiration events and updates the lease persistence mechanism to use the new schema package for storing lease data.
server/lease · high confidence
Refactor etcdserver bootstrap and introduce version adapter
The server/etcdserver package has been restructured to improve modularity and testability. A new bootstrap flow consolidates the initialization of the backend, WAL, cluster, and Raft components into a single, ordered sequence, extracting these steps into dedicated functions and structs (e.g., bootstrappedServer, bootstrappedStorage). Additionally, a serverVersionAdapter is introduced to decouple version-related operations (such as cluster version updates and downgrade handling) from the core EtcdServer, allowing the version monitor to interact with the server through a cleaner interface. These changes also include moving corruption checking logic into a dedicated checker and updating HTTP error handling types.
server/etcdserver · high confidence
Refactored v3 gRPC server into modular, new-package components
The v3 RPC server implementation has been reorganized into a set of distinct, single-responsibility files within the \server/etcdserver/api/v3rpc\ package. This change introduces dedicated server implementations for each API domain—\auth.go\ for authentication, \key.go\ for KV operations, \lease.go\ for lease management, \maintenance.go\ for cluster maintenance, and \member.go\ for cluster membership—along with supporting infrastructure in \grpc.go\ (server setup and interceptor chaining), \header.go\ (response header population), \health.go\ (gRPC health status notifications), \interceptor.go\ (request logging and validation), \quota.go\ (storage quota enforcement), and \codec.go\ (protobuf serialization). This modular structure improves code maintainability and separation of concerns without altering the external gRPC API contract.
server/etcdserver/api/v3rpc · high confidence
etcdctl v3 commands reorganized into modular command files
The etcdctl v3 command implementation has been restructured from a monolithic file into separate, modular Go files (e.g., alarm\_command.go, auth\_command.go, check.go, compaction\_command.go, completion\_command.go, defrag\_command.go, del\_command.go, downgrade\_command.go, elect\_command.go, ep\_command.go, get\_command.go, global.go, groups.go, help\_command.go, lease\_command.go). This change improves code maintainability and readability by isolating each command's logic into its own file, while preserving all existing functionality and command-line interfaces for users.
etcdctl/ctlv3/command · high confidence
Behavioural changes
1 commit (0 fixes) modifying server
A change to existing behaviour in server — 1 commit, 4 files: “etcdserver: drop expected legacy v2 WAL requests instead of replaying them”.
server/internal · medium confidence · unverified
8 commits (0 fixes) modifying scripts
A change to existing behaviour in scripts — 8 commits, 9 files: “scripts: move verify-go-version.sh to verify/go-version.sh”; “scripts: move verify-bom to scripts/verify/bom.sh”; “scripts: move verify-lint to scripts/verify/lint.sh”; and 5 more.
scripts/verify · medium confidence · unverified
Add contrib OWNERS file and update README with new examples
The contrib directory now includes an OWNERS file to manage pull request labels and a refreshed README that documents available scripts. The README highlights new or updated examples, including a systemd unit file for deploying etcd on systemd-based distributions, a multi-node cluster setup, a distributed locking example, and a Grafana/Prometheus monitoring mixin.
contrib · high confidence
Add proxy certificate generation fixtures
The \pkg/proxy/fixtures\ directory now includes a script (\gencerts.sh\) and associated configuration files (\ca-csr.json\, \gencert.json\, \server-ca-csr.json\) to generate test certificates using \cfssl\. This change introduces pre-generated CA and server certificates (\ca.crt\, \server.crt\) and keys (\server.key.insecure\) specifically for the proxy package, replacing previous fixture locations and ensuring consistent, reproducible TLS test data for local development and testing.
pkg/proxy/fixtures · high confidence
Add support for etcd versions 3.6, 3.7, and 3.8
The capability management system in the server API now recognizes and enables features for etcd versions 3.6, 3.7, and 3.8. Previously, capability maps only extended up to version 3.5; the new \capability.go\ file explicitly adds entries for these later versions, ensuring that authentication and v3 RPC capabilities remain enabled as clusters upgrade to these releases.
server/etcdserver/api · high confidence
Adopts gRPC's standard resolver and round\_robin load balancing
The client now uses a custom resolver that registers under the 'etcd-endpoints' scheme and explicitly configures the 'round\_robin' load balancing policy via the gRPC service config. This replaces the previous internal balancer implementation with standard gRPC components, ensuring that endpoint updates are emitted as a single resolver state change to prevent connection teardowns during load balancer switches.
client/v3/internal/resolver · high confidence
Backend storage restructured into a dedicated package with enhanced transaction safety and metrics
The backend storage implementation has been moved into a new \server/storage/backend\ package, introducing a standardized \Backend\ interface and separating transaction logic into \batch\_tx.go\ and \read\_tx.go\. This change adds \LockInsideApply\ and \LockOutsideApply\ methods to enforce correct transaction locking contexts, preventing data races during concurrent access. It also introduces a \txPostLockInsideApplyHook\ mechanism to execute logic immediately after locking, and adds Prometheus metrics for defragmentation activity and commit latencies. Additionally, the write buffer now deduplicates keys when writing back to an empty read buffer bucket, and defragmentation now restores original BoltDB options after completion. Also in this area: Non-blocking defragmentation reduces request latency during maintenance.
server/storage/backend, server/storage/backend/testing · high confidence
Centralized cluster version and downgrade management
The version detection and downgrade logic has been consolidated into the new \server/etcdserver/version\ package. This change introduces a \Monitor\ that automatically updates the cluster and storage versions based on the minimum server version of cluster members, and a \Manager\ that handles the validation, enabling, and cancellation of downgrade operations. The system now strictly enforces that downgrades can only target the immediately preceding minor version and panics if a server with a lower version than the determined cluster version attempts to join, ensuring safer and more predictable cluster version transitions.
server/etcdserver/version · high confidence
Centralized etcd server configuration model
The server configuration is now consolidated into a single \ServerConfig\ struct in the \server/config\ package. This change introduces explicit support for new operational settings, including distributed tracing via OpenTelemetry (\EnableDistributedTracing\), memory locking (\MemoryMlock\), bootstrap defrag thresholds (\BootstrapDefragThresholdMegabytes\), and learner limits (\MaxLearners\). It also exposes gRPC stream limits (\MaxConcurrentStreams\) and backend tuning options, providing a unified entry point for all etcd server runtime parameters.
server/config · high confidence
Centralized version management and API versioning
The version information for the API has been centralized into a new \api/version\ package, defining supported cluster versions (3.0 through 4.0) and the current server version (3.8.0-alpha.0). This change introduces an \APIVersion\ field that automatically derives the major.minor version from the semantic version string, and adds a \storage\ field to the version response structure to expose storage-specific versioning details to users.
api/version · high confidence
Concurrency primitives (mutex, election, STM) moved to client/v3/concurrency
The concurrency package—providing distributed locks (Mutex), leader elections (Election), and software transactional memory (STM)—has been relocated to the client/v3/concurrency directory. This change updates the import paths for these primitives, requiring users to import them from the new client/v3 location rather than the previous client location.
client/v3/concurrency · high confidence
Deprecate custom test assertions in favor of testify
The \client/pkg/testutil\ package has deprecated its custom assertion functions (\AssertNil\, \AssertNotNil\, \AssertTrue\, \AssertFalse\) in \assert.go\. Users should migrate to the standard \github.com/stretchr/testify/assert\ and \github.com/stretchr/testify/require\ packages to ensure consistent test behavior and better integration with the Go testing ecosystem.
client/pkg/testutil · high confidence
Deprecated local-tester tool with Procfile-based fault injection
The local-tester tool, which runs a fault-injected etcd cluster using local processes and network bridges, is now deprecated in favor of the robustness testing suite and will be removed in a future release. This change introduces a Procfile configuration to manage cluster processes (etcd nodes, bridges, and stress tests) via goreman, and adds fault injection capabilities through bridge.sh (simulating network issues like delays, blackholes, and corruption) and faults.sh (randomly cycling members, killing nodes, and activating failpoints).
tools/local-tester · high confidence
Documentation directory restructured with new OWNERS and README
The Documentation directory has been restructured to support a new site generation system. An OWNERS file has been added to automate labeling for documentation pull requests, and the README has been updated to clarify that this directory contains internal contributor documentation, directing users and developers to the etcd.io website for public-facing docs.
Documentation · high confidence
Event type constants moved into Event enum with backward-compatibility aliases
The mvccpb package now defines PUT and DELETE as members of the Event\_EventType enum (Event\_PUT, Event\_DELETE) rather than top-level constants. To ensure a smooth transition, deprecated aliases PUT and DELETE are provided in deprecated.go, mapping to the new enum values and scheduled for removal in v3.8. Additionally, helper methods IsCreate() and IsModify() are added to the Event type to simplify checking whether an event represents a key creation or a modification.
api/mvccpb · high confidence
Extracted consistent index management into a dedicated cindex package
The logic for tracking and persisting the consistent index and term has been moved from the etcdserver into a new, standalone \cindex\ package. This change introduces a \ConsistentIndexer\ interface and a \consistentIndex\ implementation that handles atomic updates and backend persistence via the \schema\ package. The new module includes a fake implementation for testing and enforces validation to prevent the consistent index from decreasing, ensuring data integrity during replication and recovery.
server/etcdserver/cindex · high confidence
File utility package moved to client/pkg/fileutil
The file utility package has been relocated from pkg/fileutil to client/pkg/fileutil. This change updates the import path for all file and directory operations, including directory creation, file locking, preallocation, and synchronization, ensuring that client-side code uses the correct module path for these shared utilities.
client/pkg/fileutil · high confidence
Improved IPv6 URL comparison and Linux default host resolution
The netutil package now correctly normalizes IPv6 addresses (handling leading zeros and case) when comparing URLs, ensuring that equivalent IPv6 addresses are treated as equal. Additionally, on Linux, the default host resolution logic has been updated to use native byte ordering for reading routing table information, improving the reliability of \GetDefaultHost\ and \GetDefaultInterfaces\.
pkg/netutil · high confidence
Improved graceful shutdown handling for Unix processes
The \pkg/osutil\ package now implements a more robust interrupt handling mechanism for Unix systems. When a SIGINT or SIGTERM signal is received, the process logs the event and executes any registered shutdown handlers. Crucially, if the process is PID 1 (the init process), it exits directly to avoid kernel issues; otherwise, it resets the signal disposition to default and re-sends the signal to ensure the process terminates. This change also introduces a testable hook (\setDflSignal\) to allow tests to override signal behavior without causing early termination.
pkg/osutil · high confidence
Introduce centralized linting and formatting configuration for the tools directory
This change establishes a dedicated configuration suite for the \tools\ directory, ensuring consistent code quality and documentation standards. It introduces a \golangci-lint\ configuration (\.golangci.yaml\) that enables a comprehensive set of linters (including \errorlint\, \staticcheck\, \testifylint\, and \revive\) and formatters (\gci\, \gofmt\, \goimports\) with specific rules tailored to the project's style. Additionally, it adds configuration files for markdown linting (\.markdownlint.jsonc\), YAML formatting (\.yamlfmt\), and YAML linting (\.yamllint\), along with an \OWNERS\ file to automate labeling for tooling-related pull requests. These configurations standardize how Go code, documentation, and configuration files are validated and formatted within this specific area of the repository.
tools · high confidence
Introduce schema package for storage backend management
The storage backend's internal structure is now managed through a new \server/storage/schema\ package, which centralizes the definition of storage buckets (such as \key\, \meta\, \lease\, \alarm\, \cluster\, \members\, and \auth\) and provides dedicated backend interfaces for managing alarms, authentication (users and roles), leases, and cluster membership. This change introduces a structured approach to schema migrations, including reversible upgrade and downgrade actions, and ensures that critical metadata like the consistent index, term, and configuration state are persisted and validated correctly within the backend.
server/storage/schema · high confidence
Introduces local feature gate implementation to replace k8s dependency
The \pkg/featuregate\ package now provides a self-contained implementation of the feature gate system, copied from \k8s.io/component-base@v0.30.1\, to eliminate circular dependencies with k8s packages. This change introduces the \New\ function which returns a \MutableFeatureGate\ interface, allowing users to manage feature flags (such as \AllAlpha\ and \AllBeta\) and register new features via the \AddFlag\ method without relying on external k8s libraries.
pkg/featuregate · high confidence
Introduces server feature gates for controlling experimental and beta capabilities
The server now exposes a feature-gate mechanism to enable or disable specific behaviors, replacing previous experimental flags. This change introduces gates for several features: FastLeaseKeepAlive (beta, enabled by default) for faster lease renewal, TxnModeWriteWithSharedBuffer (beta, enabled by default), and PriorityRequest (alpha) to prioritize requests like LeaseRevoke under overload. It also includes alpha gates for StopGRPCServiceOnDefrag, InitialCorruptCheck, CompactHashCheck, LeaseCheckpoint, LeaseCheckpointPersist, and SetMemberLocalAddr, allowing users to opt into or out of these behaviors explicitly.
server/features · high confidence
Introduction of v2 API error handling package
The v2error package has been added to define error codes, messages, and HTTP status mappings for the legacy v2 API. This change introduces the Error struct and its associated methods (NewError, WriteTo, StatusCode) which allow the server to serialize and return standardized JSON error responses for v2 operations. The package includes a comprehensive map of error codes (e.g., KeyNotFound, TestFailed, RaftInternal) to their human-readable messages and corresponding HTTP status codes, ensuring consistent error reporting for v2 clients. This is part of the broader effort to maintain and eventually deprecate the v2 API in favor of v3.
server/etcdserver/api/v2error · high confidence
JWT authentication now supports EdDSA and accepts bearer-prefixed tokens
The etcd server's authentication module has been updated to support the EdDSA algorithm for JWT tokens, in addition to the existing RSA, ECDSA, and HMAC methods. The token provider now also accepts authentication tokens that include the 'Bearer ' prefix, improving compatibility with standard HTTP client libraries. Internally, the implementation has migrated to the golang-jwt/jwt v5 library and includes fixes for token parsing and logging to prevent panics and reduce noise.
server/auth · high confidence
MVCC compaction hash verification and consistency fixes
The MVCC storage layer now includes robust hash verification to ensure data consistency across compaction and cluster upgrades. A new \HashStorage\ component caches and computes hashes of the keyspace by revision, enabling the \HashByRev\ API to detect corruption or mismatched states. The compaction logic has been updated to preserve tombstones at the compaction revision boundary, preventing hash mismatches between older and newer server versions during rolling upgrades. Additionally, the system now verifies that watch responses have revisions greater than the minimum required revision, fixing potential event loss and ensuring monotonic revision progression.
server/storage/mvcc · high confidence
Membership data is now persisted to the backend storage
The membership subsystem now reads and writes cluster membership information (members, removed IDs, and cluster version) directly to the backend storage via a new \MembershipBackend\ interface, rather than relying solely on the legacy v2 store. This change enables the system to recover accurate membership state from the backend during startup and ensures that membership changes are durable in the primary storage layer.
server/etcdserver/api/membership · high confidence
Migrate authpb to protobuf-go v2 and update Permission enum naming
The authpb package has been regenerated using the new google.golang.org/protobuf runtime (v2) instead of the legacy gogo/protobuf library, resulting in updated generated code in auth.pb.go. As part of this migration, the Permission enum constants have been renamed to be scoped under the Permission type (e.g., authpb.Permission\_READ instead of authpb.READ). To maintain backward compatibility, deprecated aliases (authpb.READ, authpb.WRITE, authpb.READWRITE) are provided in deprecated.go but are scheduled for removal in v3.8.
api/authpb · high confidence
Migrate to Google Protobuf and add RangeStream RPC
The etcd server protocol buffer definitions and generated Go code in api/etcdserverpb have been regenerated using the google.golang.org/protobuf runtime (protoc-gen-go v1.36.12) instead of the previous gogo/protobuf implementation. This migration updates the generated code structure and dependencies. Additionally, a new RangeStream RPC method has been added to the KV service, allowing clients to receive range results as a server-side stream, and the InternalRaftRequest message now includes a DowngradeVersionTest field for internal testing purposes.
api/etcdserverpb · high confidence
Migrated raft HTTP transport to go.etcd.io/raft/v3
The raft HTTP transport layer in \server/etcdserver/api/rafthttp\ has been updated to use the \go.etcd.io/raft/v3\ package. This migration updates the internal message encoding and decoding logic to align with the new raft protocol buffer definitions, ensuring compatibility with the upgraded raft core. The change includes updates to the HTTP handlers and stream writers to process the new message formats, while maintaining the existing peer communication and snapshot transfer behaviors.
server/etcdserver/api/rafthttp · high confidence
New /livez and /readyz health endpoints with serializable read support
The etcd HTTP API now exposes dedicated Kubernetes-style health endpoints: /livez (process liveness) and /readyz (cluster readiness), alongside an enhanced /health endpoint. The /health endpoint now supports a serializable read mode via the ?serializable=true query parameter, allowing probes to validate the health of the local etcd process independently of the cluster's leader status. Additionally, the /health endpoint accepts an ?exclude parameter to filter out specific alarm types (e.g., NOSPACE) from the health check result, and Prometheus metrics have been added to track health check success and failure counts.
server/etcdserver/api/etcdhttp · high confidence
New endpoint parsing logic for gRPC compatibility
The client now uses a dedicated \Interpret\ function in \client/v3/internal/endpoint\ to translate etcd-style endpoint strings (including \http\, \https\, \unix\, and \unixs\ schemes) into addresses and server names suitable for gRPC. This change ensures that TLS certificate validation uses the correct server name and that credential requirements are accurately determined based on the scheme, replacing the previous ad-hoc parsing logic.
client/v3/internal/endpoint · high confidence
New storage package consolidates backend, quota, and WAL management
The server/storage package has been introduced to centralize storage-related logic. It provides the backend initialization and snapshot recovery mechanisms (backend.go), implements the backend space quota enforcement and cost calculation for transactions (quota.go), and manages the Write-Ahead Log (WAL) interface and snapshot state (storage.go). Additionally, it introduces hooks for persisting consistent index and cluster configuration state (hooks.go), exposes Prometheus metrics for backend quota usage (metrics.go), and includes utilities for cluster membership changes and WAL entry analysis (util.go).
server/storage · high confidence
Read logic moved to dedicated subpackage with new Prometheus metrics
The linearizable read index handling logic has been extracted from the main etcd server into a new \server/etcdserver/read\ subpackage. This change introduces two new Prometheus metrics, \slow\_read\_indexes\_total\ and \read\_indexes\_failed\_total\, to track pending read indexes that are out of sync with the leader and failed read index requests, respectively. The refactoring also includes moving existing tests for the read index functionality into this new package.
server/etcdserver/read · high confidence
Refactor etcd CLI into a Cobra-based command structure
The etcd server and proxy entry points have been restructured to use the Cobra command library, introducing dedicated subcommands for 'gateway' and 'grpc-proxy' alongside the main server invocation. This change consolidates command-line flag parsing and help documentation into a unified structure, moving configuration logic into a dedicated \config.go\ module and separating proxy startup logic into specific handler files. Users will now interact with the etcd binary through a consistent subcommand interface, with help text and flag definitions centralized in the new \help.go\ and \config.go\ files.
server/etcdmain · high confidence
Refactored V3 apply logic into a modular, testable apply package
The V3 request application logic has been moved from the etcdserver into a new, standalone \server/etcdserver/apply\ package. This change introduces a layered applier architecture where the \UberApplier\ orchestrates specific appliers for auth, quota, and corruption handling, allowing the server to dynamically reject writes when alarms (like NOSPACE or CORRUPT) are active. The refactoring also extracts transaction and membership apply logic into dedicated files, adds comprehensive tests for the auth and uber appliers, and simplifies the codebase by removing unused context parameters and consolidating v2 apply logic.
server/etcdserver/apply · high confidence
Refactored alarm storage to use schema backend interface
The alarm management logic in the v3alarm package has been updated to persist and retrieve alarm states through a new schema.AlarmBackend interface rather than direct backend access. This change decouples the alarm store from the underlying storage implementation, allowing the alarm bucket operations to be managed via the schema package, which aligns with the broader server storage restructuring.
server/etcdserver/api/v3alarm · high confidence
Refactored client transport with configurable timeouts, socket options, and TLS keep-alive
The client transport layer has been restructured to provide finer control over network connections. Listeners now support configurable read and write timeouts via a new options-based API, and TCP keep-alive is explicitly enabled with a 30-second period to detect dead peers. Socket options for SO\_REUSEPORT and SO\_REUSEADDR are now available to improve restart reliability and port reuse. TLS handshakes are protected by a 10-second timeout to prevent blocking, and the transport now supports multiple allowed client TLS identities (CNs and hostnames) instead of single values.
client/pkg/transport · high confidence
Refactored logging utilities and added path utility
The logging utilities in client/pkg/logutil have been restructured to provide more robust configuration and validation. The log format is now explicitly configurable via 'json' or 'console' (defaulting to JSON), with invalid formats returning an error and empty inputs falling back to the default. Timestamp encoding has been standardized to microsecond precision (e.g., 2006-01-02T15:04:05.000000Z0700) to match historic formats. The MergeOutputPaths function was simplified to handle path deduplication and '/dev/null' discarding more cleanly. Additionally, a new pathutil package was introduced with a CanonicalURLPath function to normalize URL paths by resolving slashes and relative components.
client/pkg/logutil · high confidence
Regenerate lease protobuf files with protoc-gen-go v1.36.12
The lease protocol buffer definitions and generated Go code in server/lease/leasepb have been regenerated using protoc-gen-go v1.36.12. This update migrates the generated code to use the standard google.golang.org/protobuf runtime instead of the legacy gogo/protobuf library, ensuring compatibility with the latest protobuf tooling and runtime standards.
server/lease/leasepb · high confidence
Regenerated gRPC-Gateway reverse proxy code for Election and Lock APIs
The HTTP reverse-proxy handlers for the v3 Election and v3 Lock gRPC services have been regenerated to align with the grpc-gateway v2 runtime. This update ensures that RESTful JSON endpoints (such as /v3/election/campaign and /v3/lock/lock) correctly translate HTTP requests into gRPC calls using the updated gateway library, maintaining compatibility with the current protobuf definitions.
server/etcdserver/api/v3election/v3electionpb/gw, server/etcdserver/api/v3lock/v3lockpb/gw · high confidence
Regenerated gRPC-Gateway reverse proxy code for etcd server API
The reverse proxy implementation in api/etcdserverpb/gw has been regenerated to align with updated protobuf definitions and the grpc-gateway/v2 library. This change updates the generated Go code (rpc.pb.gw.go) that translates gRPC calls into RESTful JSON APIs, ensuring compatibility with the latest protocol buffer standards and gateway runtime behavior.
api/etcdserverpb/gw · high confidence
Regenerated snapshot protobuf code using protoc-gen-go v1.36.12
The snapshot protocol buffer definitions and generated Go code in the server snap package have been regenerated using protoc-gen-go v1.36.12 and protoc v3.20.3. This update migrates the generated code to use the google.golang.org/protobuf runtime (protoimpl) instead of the legacy gogo/protobuf library, dropping previous gogo-specific options like nullable and getters. For users, this ensures the snapshot serialization logic remains compatible with the updated protobuf toolchain while maintaining the same message structure (Snapshot with crc and data fields).
server/etcdserver/api/snap/snappb · high confidence
Regenerated v3election protobuf and gRPC code with protoc-gen-go v1.36.12
The generated Go code for the v3election service (v3election.pb.go, v3election\_grpc.pb.go, and v3election.proto) has been regenerated using protoc-gen-go v1.36.12 and protoc v3.20.3. This update switches the underlying protobuf runtime from gogo/protobuf to google.golang.org/protobuf, which changes the internal message state structures and serialization behavior. Users relying on the v3election gRPC interface will see the generated client and server stubs updated to use the new protobuf reflection API, ensuring compatibility with the latest gRPC-Go v1.64.0+ requirements.
server/etcdserver/api/v3election/v3electionpb, server/etcdserver/api/v3lock/v3lockpb · high confidence
Server entrypoint and dependency guard configuration added
The server location now includes a main.go entrypoint that delegates to the etcd main package, ensuring the binary remains 'go getable', and a .gomodguard.yaml configuration file that explicitly blocks forbidden dependencies such as go.etcd.io/etcd modules. Additionally, a LICENSE file (Apache 2.0) has been added to define the terms for use and distribution.
server · medium confidence
Snapshot save now returns the etcd server version
The SaveWithVersion function in the snapshot package now returns the etcd server version retrieved from the snapshot response, allowing users to verify the version of the backed-up data. Additionally, the function now accepts a zap logger to enable configurable logging for snapshot operations, and it ensures proper cleanup of temporary files and file descriptors to prevent resource leaks.
client/v3/snapshot · high confidence
Snapshotter now fsyncs the directory after saving database snapshots
The snapshot logic in the server now ensures that the directory containing the new snapshot database file is synced to disk after the file is saved. This change prevents data loss in the event of a crash during the snapshot save process, ensuring that the snapshot receiver can safely process the Raft message only after the snapshot is durable on storage.
server/etcdserver/api/snap · high confidence
Standardized gRPC error codes and introduced client-side error wrappers
The v3 RPC layer now exposes context cancellation and deadline errors as their specific gRPC codes (Canceled, DeadlineExceeded) instead of the generic Unknown code, and corrects the code for non-retryable Unavailable errors to FailedPrecondition. Additionally, the rpctypes package now provides client-side error wrappers (e.g., ErrKeyNotFound) that allow users to programmatically check for specific error conditions, while server-side errors are consistently generated using status.Error().
api/v3rpc · high confidence
Transaction logic refactored into dedicated operation files with new range metrics
The transaction handling code in the etcd server has been reorganized into the new \server/etcdserver/txn\ package, splitting the previous monolithic implementation into dedicated files for \put\, \delete\, and \range\ operations. This refactoring introduces a new Prometheus metric, \etcd\_server\_range\_duration\_seconds\, to track the latency of range requests within transactions, and includes comprehensive unit and benchmark tests to verify the new structure and performance characteristics.
server/etcdserver/txn · high confidence
Updated etcd gRPC resolver to use the new Endpoint API
The etcd gRPC resolver has been updated to align with grpc-go 1.30+ conventions. It now constructs resolver states using the new \resolver.State.Endpoints\ structure (containing \Endpoint\ objects with \Addresses\) instead of the deprecated \resolver.State.Addresses\. Additionally, the resolver implementation now strips the leading slash from the target path to ensure correct endpoint resolution.
client/v3/naming/resolver · high confidence
WAL decoder exposes CRC mismatch details and supports inspection mode
The WAL decoder now reports the specific file name and byte offset when a CRC mismatch occurs, improving diagnostics for corrupted logs. Additionally, an optional inspection mode allows the decoder to continue processing and preserve potentially corrupted record content even when CRC errors are detected, which is useful for tools analyzing damaged WAL files.
server/storage/wal · high confidence
WAL snapshot validation and protobuf migration
The WAL protobuf definitions have been regenerated using the new google.golang.org/protobuf runtime (protoc-gen-go v1.36.12), switching field accessors to pointer-based getters. Additionally, a new validation function ensures that newly written WAL snapshots contain required fields (index, term, and ConfState for non-initial snapshots), preventing the persistence of malformed state that could cause issues during recovery.
server/storage/wal/walpb · high confidence
etcdctl v3 CLI restructured with hidden global flags and new commands
The etcdctl v3 command-line interface has been reorganized to improve usability and clarity. Global flags (such as endpoints, authentication, and TLS settings) are now hidden by default from the main help output; users can view them using the new 'etcdctl options' command. The CLI now supports a wider range of output formats, including 'fields', 'json', 'protobuf', 'simple', and 'table', and allows configuring the write-out format via the '--write-out' flag. Several new subcommands have been added, including 'alarm', 'move-leader', 'check' (for performance diagnostics), 'downgrade', and 'completion' (for shell autocompletion). Additionally, the default endpoint is explicitly set to '127.0.0.1:2379', and new flags for controlling request/response byte sizes ('--max-request-bytes', '--max-recv-bytes') and keep-alive timeouts have been introduced.
etcdctl/ctlv3 · high confidence
etcdctl v3 becomes the default API version
The etcdctl command-line client now defaults to the v3 API, removing the need to set the ETCDCTL\_API=3 environment variable for standard usage. Users relying on the legacy v2 API must explicitly set ETCDCTL\_API=2 to access v2-specific commands and behavior, as documented in the new README and READMEv2 files.
etcdctl · high confidence
Test coverage
Add Antithesis instrumentation and testing infrastructure for the etcd server; Add test directory metadata and placeholder CI script; Added Antithesis entrypoint test for etcd cluster health verification; Added Antithesis random number generation wrappers for testing; Added Antithesis robustness traffic generation test; Added Antithesis robustness validation driver; Added WAL testing utilities; Added environment-based path configuration for robustness tests; Added expired certificate fixtures for integration testing; Added integration tests and examples for clientv3 concurrency primitives; Added integration tests for clientv3 example code; Added integration tests for clientv3 snapshot operations; Added integration tests for experimental clientv3 recipes; Added integration tests for gRPC proxy cluster, KV, and registration functionality; Added integration tests for the embedded etcd server; Added integration tests for the v2 store; Added robustness coverage tests for Kubernetes-Etcd API usage; Added robustness test client infrastructure and race-condition tests; Added robustness test coverage for client report persistence and WAL entry merging; Added robustness validation tests for etcd linearizability and watch guarantees; Added test decoder scripts for etcd log validation; Added test fixtures for TLS certificates and Ed25519 keys; Added test patches for distributed tracing coverage in etcd-k8s tests; Added test script for devcontainer validation; Added tests for robustness test configuration helpers; Consolidate v3 watch integration tests into a single directory; Expanded end-to-end test coverage for etcd cluster operations; Expanded robustness test coverage for etcd state models; Expanded robustness test scenarios with configurable traffic profiles; Integration test suite reorganization and expansion; Integration tests for clientv3 lease and leasing functionality; Integration tests for clientv3 naming endpoints and resolvers; Integration tests for etcd snapshot restore operations; New common test configuration framework for cluster and client options; New common test framework for e2e and integration tests; New e2e test framework for etcd cluster management; New integration test framework infrastructure; New integration tests for clientv3; New integration tests for clientv3 connectivity resilience; New robustness testing framework with regression tracking and CI integration; New robustness tests for member replacement, downgrade, and watch stream failpoints; New robustness traffic generation framework; New test utilities for MVCC compaction and database corruption; New test utility helpers for execution, logging, and KV operations; etcd-dump-logs: updated expected test outputs for decoder and entry-type filtering.
Dependencies
Dependency updates across etcd modules
This change updates dependencies across the etcd codebase, including the api, cache, client/pkg, and client/v3 modules. Key updates include gRPC to v1.83.2, protobuf to v1.36.12, and golang.org/x/net to v0.59.0. The Go toolchain is set to v1.27.1, and the Go language version is set to v1.27. Other dependencies like testify, zap, and prometheus client libraries are also updated to their latest versions.
(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 64 → 65 (+1.6)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 72 → 74 (+2.3)
- Architecture 79 → 79 (+0.1)
- Maturity 69 → 71 (+1.7)
- Readiness 71 → 72 (+1.4)
- Security 55 → 56 (+0.5)
- Performance 79 → 100 (+21.1)
Resolved (45)
- Duplicated block (11 lines × 2) (tools/rw-heatmaps/pkg/chart/heatmaps.go)
- FunctionTooLong: main.main (tools/etcd-dump-metrics/main.go)
- Hotspot: tools/etcd-dump-logs/main.go (tools/etcd-dump-logs/main.go)
- No ADRs found
- Off-boarding risk: anonymized user #1
- Orphaned file (etcdutl/etcdutl/printer.go)
- Orphaned file (server/etcdserver/api/v2store/metrics.go)
- Outdated: github.com/GoogleCloudPlatform/testgrid
- Secret: generic-api-key (Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go)
- Secret: private-key (Godeps/_workspace/src/github.com/bradfitz/http2/h2demo/rootCA.key)
- Secret: private-key (Godeps/_workspace/src/github.com/bradfitz/http2/h2demo/server.key)
- Secret: private-key (hack/scripts-dev/docker-dns-srv/certs-gateway/server.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns-srv/certs-wildcard/server.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns-srv/certs/server.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns/certs-common-name-auth/server.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns/certs-common-name-multi/server-1.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns/certs-common-name-multi/server-2.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns/certs-common-name-multi/server-3.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns/certs-common-name/server.key.insecure)
- Secret: private-key (hack/scripts-dev/docker-dns/certs-gateway/server.key.insecure)
- …and 25 more
New (98)
- Demux.updateStoreLocked (cognitive 16) (cache/demux.go)
- Edited copies of one member (3 members, 10+ corresponding lines) (etcdctl/ctlv3/command/del_command.go)
- Edited copies of one member (3 members, 12+ corresponding lines) (client/v3/maintenance.go)
- Edited copies of one member (3 members, 18+ corresponding lines) (pkg/proxy/server.go)
- Edited copies of one member (3 members, 25+ corresponding lines) (server/etcdserver/api/membership/cluster.go)
- Edited copies of one member (3 members, 27+ corresponding lines) (pkg/netutil/routes_linux.go)
- Edited copies of one member (3 members, 28+ corresponding lines) (server/etcdserver/v3_server.go)
- Edited copies of one member (3 members, 37+ corresponding lines) (server/auth/options.go)
- Edited copies of one member (4 members, 11+ corresponding lines) (client/pkg/fileutil/lock_flock.go)
- Edited copies of one member (4 members, 13+ corresponding lines) (server/etcdserver/api/v3rpc/key.go)
- Edited copies of one member (4 members, 17+ corresponding lines) (tools/etcd-dump-db/main.go)
- Edited copies of one member (4 members, 7+ corresponding lines) (server/proxy/grpcproxy/adapter/election_client_adapter.go)
- Edited copies of one member (4 members, 7+ corresponding lines) (server/proxy/grpcproxy/adapter/election_client_adapter.go)
- Edited copies of one member (5 members, 12+ corresponding lines) (etcdctl/ctlv3/command/auth_command.go)
- Edited copies of one member (5 members, 18+ corresponding lines) (etcdctl/ctlv3/command/compaction_command.go)
- Edited copy of a member (10 corresponding lines) (etcdctl/ctlv3/command/util.go)
- Edited copy of a member (11 corresponding lines) (client/v3/ctx.go)
- Edited copy of a member (11 corresponding lines) (client/v3/experimental/recipes/client.go)
- Edited copy of a member (11 corresponding lines) (pkg/netutil/netutil.go)
- Edited copy of a member (11 corresponding lines) (pkg/proxy/server.go)
- …and 78 more
Changes since last survey
- 75 commits — 65 feature/other, 10 fixes
By area
- (repo) — 34 commits
- (root) — 18 commits
- .github/workflows — 4 commits
- CHANGELOG/CHANGELOG-3.5.md — 3 commits
- server/etcdserver — 3 commits
- tests/robustness — 3 commits
- server/storage — 2 commits
- CHANGELOG/CHANGELOG-3.7.md — 1 commit
- Documentation/contributor-guide — 1 commit
- cache/cache.go — 1 commit
- etcdctl/ctlv3 — 1 commit
- etcdutl/etcdutl — 1 commit
- scripts/test.sh — 1 commit
- tools/mod — 1 commit
- tools/testgrid-analysis — 1 commit
Notable commits
- fix: CHANGELOG(3.5,3.6,3.7): add force-new-cluster commit-index fix entries
- fix: Fix failing tests
- fix: Merge pull request #22655 from AliasJeff/fix-22646-force-new-cluster-backend-ahead
- fix: Merge pull request #22678 from supahero1/fix-coverage-watch-prev-kv
- fix: Merge pull request #22778 from Abhayrkhot/fix/unexported-return-traffic-stats
- fix: Merge pull request #22785 from Abhayrkhot/fix/move-verify-lint-script
- fix: Merge pull request #22790 from rattboi/fix/move-verify-grpc-experimental-script
- fix: Merge pull request #22799 from rattboi/fix/verify-yamllint-standalone-script
- fix: etcdutl : Fix lint failure
- fix: tests/robustness/traffic: fix unexported-return linter warnings
- change: Add etcd and Kubernetes version matrix
- change: Bump Go to 1.27.4
- change: CHANGELOG: should be able to replay lagacy WAL entries
- change: Define alarmStore as an atomic pointer to avoid race condition
- change: Dockerfile: bump base image to distroless static-debian13
- change: Export stores under tests/robustness/traffic to satisfy linter
- change: Merge pull request #22634 from NUAAwqy/taiyi/etcd-22633-v2-wal-compat
- change: Merge pull request #22660 from etcd-io/dependabot/go_modules/github.com/prometheus/common-0.72.1
- change: Merge pull request #22661 from etcd-io/dependabot/go_modules/github.com/GoogleCloudPlatform/testgrid-0.0.177
- change: Merge pull request #22670 from vivekpatani/distroless-debian13
- …and 55 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
etcd-io/etcd was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 1b969e26a2c65733f1ff696e3537373d56b3ae67 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.