flippercloud/flipper
41.8
Weak · 14 November 2026
12.2k
lines of production code
Ruby
with JavaScript
5
measurements over time
What this system is
Features
Add MongoDB example demonstrating basic feature toggle usage
A new example script (examples/mongo/basic.rb) has been added to demonstrate how to initialize the Flipper MongoDB adapter, configure the connection URL via environment variables, and perform basic enable/disable operations on a feature toggle.
examples/mongo · high confidence
Add Noop instrumenter with AS::Notifications-compatible interface
A new Noop instrumenter class has been added to the Flipper library, providing a no-operation implementation for feature flag instrumentation. This class implements the standard instrument interface by accepting a name and payload, and crucially, it yields the payload to a provided block if one is given, mirroring the behavior of ActiveSupport::Notifications. This allows users to integrate Flipper with systems expecting this notification pattern without performing any actual instrumentation work.
lib/flipper/instrumenters · high confidence
Add UI decorators for features and gates
This change introduces new decorator classes for the Flipper UI: \Flipper::UI::Decorators::Feature\ and \Flipper::UI::Decorators::Gate\. The \Feature\ decorator enhances the display of feature flags by providing human-readable names, color-coded status classes (success for on, danger for off, warning for conditional), and a summary of enabled gates (actors, groups, percentages) with escaped HTML for tooltips. It also enables sorting features by state. The \Gate\ decorator wraps individual gates to provide a JSON-serializable representation, handling the conversion of set values to arrays for proper JSON output.
lib/flipper/ui/decorators · high confidence
Add basic Redis adapter example
A new example script (examples/redis/basic.rb) demonstrates how to use the Flipper Redis adapter. The script sets up the environment using bundler, requires the adapter, and shows enabling and disabling a feature flag, printing the status to the console.
examples/redis · high confidence
Add basic Sequel example for Flipper integration
A new example script (examples/sequel/basic.rb) demonstrates how to integrate Flipper with the Sequel ORM. It shows setting up an in-memory SQLite database, running the necessary migration to create Flipper tables, and performing basic feature flag enable/disable operations.
examples/sequel · high confidence
Add basic and import usage examples for the Rollout adapter
New example scripts have been added to demonstrate how to use the Flipper Rollout adapter. The basic example shows how to configure a separate Flipper instance backed by the Rollout adapter, while the import example demonstrates how to migrate feature flags from a Rollout instance into the default Flipper Redis adapter.
examples/rollout · high confidence
Add migration templates for updating Flipper schema
The generator now includes migration templates (01\_create\_flipper\_tables.rb and 02\_change\_flipper\_gates\_value\_to\_text.rb) to help users upgrade their database schema. The first migration creates the feature and gate tables with appropriate indexes, supporting table prefixes. The second migration updates the gate value column from string to text to allow larger values, ensuring idempotency and handling index removal for compatibility with older Rails versions.
lib/generators/flipper/templates/update · high confidence
Add structured logging and StatsD metrics for Flipper operations
Flipper now includes built-in instrumentation via a new LogSubscriber and StatsdSubscriber. The LogSubscriber provides detailed debug-level logs for feature and adapter operations, including operation type, result, duration, and relevant context like actors or gate names, with compatibility handling for different Rails/ActiveSupport versions. The StatsdSubscriber automatically reports timing and counter metrics to a configured StatsD client for feature operations (e.g., enabled/disabled counts) and adapter operations, enabling performance monitoring and observability without requiring external configuration.
lib/flipper/instrumentation · high confidence
Added Active Record adapter usage examples
New example scripts have been added to the examples/active\_record directory to demonstrate how to use the Flipper Active Record adapter. These include basic enable/disable usage, configuring a cached adapter with ActiveSupport::Cache::MemoryStore, and a migration script for converting individual actors to groups to optimize performance.
_examples/active\record · high confidence
Added JSON and Gzip serializers for feature flag data
Flipper now includes built-in serializers to convert feature flag data into JSON format and compress it using Gzip. This allows users to easily serialize and deserialize their feature sets for storage or transmission, with the Gzip serializer providing a lightweight compression layer over the JSON output.
lib/flipper/serializers · high confidence
Added Rack API example configurations
New Rack application files (basic.ru, custom\_memoized.ru, memoized.ru) have been added to the examples/api directory, providing users with ready-to-run configurations for the Flipper API. These examples demonstrate how to initialize the API with different setups, including a basic PStore adapter, an instrumented adapter with ActiveSupport notifications, and a configuration using the Memoizer middleware.
examples/api · high confidence
Added benchmarking suite for Flipper performance analysis
This change introduces a new set of benchmarking scripts in the \benchmark/\ directory to measure and compare the performance of various Flipper operations. The suite includes benchmarks for Active Record adapter features (such as \preload\_all\ and \features\ retrieval), typecasting performance for boolean, integer, float, and number conversions, and the overhead of instrumentation via ActiveSupport::Notifications. It also provides profiling capabilities for the \enabled?\ method and compares performance when checking feature flags for single versus multiple actors.
benchmark · high confidence
Added comprehensive Flipper usage examples
The examples directory now includes a suite of demonstration scripts covering core Flipper capabilities, including basic feature toggling, configuring the default memory adapter, enabling features for specific actors and groups, and using percentage-based rollouts for both actors and time. Additional examples demonstrate advanced patterns such as importing and mirroring feature states between adapters (e.g., Redis to ActiveRecord), instrumentation via ActiveSupport::Notifications, memoization for performance, and strict mode validation.
examples · high confidence
Added poll interval dynamic adjustment example
Added a new interactive demo in \examples/cloud/poll\_interval\ that illustrates how the Flipper Cloud poller dynamically adjusts its polling frequency based on the \poll-interval\ header from the server and how it gracefully handles shutdown requests via the \poll-shutdown\ header. The example includes a local test server (\server.rb\) and a client (\client.rb\) to demonstrate real-time interval changes, minimum interval enforcement (10 seconds), and resilient shutdown behavior.
_examples/cloud/poll\interval · high confidence
Executable entry point added to exe directory
A new executable script named 'flipper' has been added to the 'exe' directory. This script serves as the entry point for the CLI, invoking the Flipper::CLI.run method with command-line arguments.
exe · high confidence
Introduce Flipper UI as a configurable web interface
Flipper now includes a built-in web UI (\lib/flipper/ui\) that provides a middleware-based interface for managing features, actors, and groups. The UI supports extensive configuration via \Flipper::UI::Configuration\, allowing users to customize banner text, enable read-only mode, control feature creation and deletion, and set up external sources for feature descriptions and actor names. It also includes security features like a Content-Security-Policy and HTML sanitization for descriptions, as well as usability features like breadcrumbs, export/import capabilities, and confirmation dialogs for destructive actions.
lib/flipper/ui · high confidence
Introduce Memoizer and SetupEnv middleware for request-scoped feature flag caching
This change introduces two new Rack middleware components: \Flipper::Middleware::Memoizer\ and \Flipper::Middleware::SetupEnv\. The Memoizer middleware enables request-scoped memoization of feature flag checks to improve performance, supporting options to preload all features, specific feature names, or use a conditional block to determine preloading behavior. It also allows customizing the environment key used to store the Flipper instance. The SetupEnv middleware facilitates the lazy initialization and injection of a Flipper instance into the request environment, supporting both direct instance injection and lazy block-based initialization, with configurable environment keys. These middleware components work together to allow efficient, per-request feature flag evaluation without requiring a global default instance if configured via the environment.
lib/flipper/middleware · high confidence
Introduce cloud telemetry submission with retry and instrumentation
Added a new telemetry subsystem for Flipper Cloud that instruments feature flag usage, stores metrics in memory, and submits them to the cloud endpoint. The system includes an Instrumenter to wrap calls and record telemetry events, a MetricStorage component for in-memory metric aggregation, and a Submitter that handles sending the data via HTTP with gzip encoding, automatic retry logic with backoff, and detailed error/instrumentation reporting.
lib/flipper/cloud/telemetry · high confidence
Introduce structured Flipper Cloud configuration, webhook sync, and migration tools
This change introduces a dedicated \Flipper::Cloud::Configuration\ class that centralizes settings for the cloud adapter, including explicit support for \poll\ and \webhook\ sync methods, configurable timeouts, and a local adapter for resilience. It adds a \MessageVerifier\ to enforce webhook signature validation with timestamp tolerance, ensuring secure cloud-to-app syncs. A new \Middleware\ handles incoming webhook requests, verifying signatures and triggering feature synchronization. Additionally, the \Migrate\ module provides CLI-accessible methods to export local features to Flipper Cloud and push existing features to a cloud project, utilizing gzip compression and robust HTTP clients.
lib/flipper/cloud · high confidence
Introduces Flipper API V1 action handlers for feature and gate management
This change adds the API V1 action controller classes for managing features and gates, including endpoints for listing/creating/removing features, enabling/disabling boolean, actor, group, percentage of actors, percentage of time, and expression gates, as well as an import endpoint. These actions define the HTTP routes, parse request parameters, enforce validation (such as percentage bounds and group registration), and return standardized JSON responses, forming the core request-handling layer for the new API V1.
lib/flipper/api/v1/actions · high confidence
New API v1 decorators for serializing actors, features, and gates
The API v1 endpoint now uses dedicated decorator classes to structure JSON responses for actors, features, and gates. Actor responses include a list of features with their enabled status for that specific actor. Feature responses include the feature key, state, and optional gate data (which can be excluded via parameters). Gate responses include the gate key, value (with sets converted to arrays for JSON compatibility), and optional name. This provides a consistent, structured format for the Flipper API v1.
lib/flipper/api/v1/decorators · high confidence
New Flipper Cloud integration examples
Added a suite of Ruby examples in the \examples/cloud\ directory demonstrating how to integrate with Flipper Cloud. These include a basic feature toggle check (\basic.rb\), a threaded polling example (\threaded.rb\), a forked-process example (\forked.rb\), a Rack application setup (\app.ru\), a backoff policy demonstration (\backoff\_policy.rb\), and a feature import utility (\import.rb\). The examples use a shared \cloud\_setup.rb\ helper to manage environment-based token configuration, allowing users to quickly test Flipper Cloud connectivity and behavior in various runtime scenarios.
examples/cloud · high confidence
New JSON export format with import size limits and non-mutating serialization
Flipper now supports exporting feature flags to a structured JSON format (v1) that can be imported back into the system. The new \Json::V1\ exporter builds a fresh data structure from the adapter's state rather than mutating the adapter's live data, ensuring export operations do not interfere with runtime flag state. The corresponding \Json::Export\ class handles parsing and typecasting of the JSON payload, and enforces a 50 MB maximum payload size to prevent abuse during import. This change introduces the necessary infrastructure for round-tripping feature flag configurations via JSON.
lib/flipper/exporters · high confidence
New Rails generators for Flipper setup, updates, and table prefixing
This change introduces a suite of new Rails generators to simplify Flipper integration and maintenance. The \flipper:setup\ generator automates the initial installation by creating a default initializer, invoking the ActiveRecord migration generator if the adapter is present, and optionally configuring a Flipper Cloud token via \.env\ files or Rails encrypted credentials. The \flipper:active\_record\ generator creates the initial migration for Flipper's feature and gate tables, while the \flipper:update\ generator allows users to add subsequent migration files for schema updates in an idempotent manner. Additionally, a \--table\_prefix\ option is supported across these generators, allowing users to prefix the generated table and index names to avoid collisions in shared databases.
lib/generators/flipper · high confidence
New adapter and integration require files for Flipper
The library now provides dedicated require files for its various storage adapters and integrations, including ActiveRecord, ActiveSupport cache store, API, Cloud, Dalli, Mongo, Redis, Sequel, and UI. This allows users to explicitly load only the components they need (e.g., \require 'flipper-active\_record'\) rather than loading the entire suite, supporting a more modular and lightweight setup.
lib · high confidence
New and refactored feature flag adapters for ActiveRecord, HTTP, and caching
This change introduces a comprehensive suite of new and refactored adapters for the Flipper feature flag system. The ActiveRecord adapter now uses dedicated model classes (Feature, Gate, Model) with explicit table name configuration and supports bulk operations like get\_all and get\_multi. A new HTTP adapter enables remote feature flag management via an API client, supporting ETag-based caching and basic authentication. Caching capabilities are expanded with new adapters for ActiveSupport::CacheStore, Dalli (Memcached), and a generic CacheBase class, while wrapper adapters like Memoizable, Instrumented, and OperationLogger provide in-memory memoization, instrumentation, and logging respectively. Additionally, new adapters for ActorLimit, DualWrite, Failover, Failsafe, Moneta, and Mongo enhance flexibility, reliability, and integration options.
lib/flipper/adapters · high confidence
New and updated UI example configurations
The examples/ui directory now includes dedicated Rack configuration files for common deployment scenarios: authorization.ru demonstrates how to implement read-only access via middleware, read\_only.ru shows the built-in read-only configuration mode, prefixed.ru illustrates mounting the UI under a specific path, and basic.ru provides a comprehensive setup with custom feature descriptions and actor names. These examples replace previous simplified setups to offer clearer, more realistic patterns for integrating the Flipper UI.
examples/ui · high confidence
New development and release scripts for local setup and testing
This change introduces a suite of new shell and Ruby scripts to streamline the developer experience. \script/bootstrap\ and \script/conductor-setup\ handle dependency installation and Ruby version management (including \mise\ integration). \script/test\ expands the test matrix to cover Rails versions 5.0 through 8.0, ensuring compatibility across a wide range of environments. \script/console\ provides a quick way to start a Pry REPL with Flipper loaded, while \script/server\ launches a local UI preview. Additionally, \script/vendor-assets\ automates the copying of frontend assets (Bootstrap, Popper) with integrity hashes, and \script/release\ offers a manual fallback for gem releases.
script · high confidence
New expression types for feature dependencies, time-based rules, and comparisons
The \lib/flipper/expressions\ directory now includes new expression classes that expand how feature flags can be evaluated. Users can now define feature dependencies using the new \FeatureEnabled\ expression, which safely handles circular references. Time-based enablements are supported via \Now\ (returning UTC time), \Time\, and \Duration\ expressions. Additionally, the library introduces logical operators (\All\, \Any\), comparison operators (\Equal\, \NotEqual\, \GreaterThan\, \LessThan\, and their \to\ variants), and type-casting expressions (\Boolean\, \Number\, \String\, \Percentage\) to allow more granular and flexible rule definitions.
lib/flipper/expressions · high confidence
New feature gates: Expression, Percentage of Actors, and Percentage of Time
This release introduces three new feature gates to the Flipper library. The Expression gate allows enabling features based on dynamic conditions evaluated against actor properties. The Percentage of Actors gate enables a feature for a deterministic subset of actors based on a CRC32 hash of their IDs, ensuring stable bucketing across upgrades. The Percentage of Time gate enables a feature for a random percentage of requests over time. These gates complement the existing Boolean, Actor, and Group gates, providing more granular control over feature rollouts.
lib/flipper/gates · high confidence
New generator templates for Flipper configuration and database migrations
The Flipper generator now includes new template files that provide a default Rails initializer with commented-out configuration options (such as memoization, preloading, and strict mode) and database migration scripts for both ActiveRecord and Sequel. The ActiveRecord migration creates the \flipper\_features\ and \flipper\_gates\ tables, including a unique index on the gates table with a specific length constraint for the value column to ensure MySQL compatibility, while the Sequel migration defines the corresponding schema using native Sequel syntax.
lib/generators/flipper/templates · high confidence
New sync adapter components for synchronizing local Flipper state with a remote source
The sync adapter now includes three new internal classes: \Synchronizer\, \FeatureSynchronizer\, and \IntervalSynchronizer\. The \Synchronizer\ class orchestrates the synchronization process by comparing local and remote adapter states, ensuring local features match remote ones by adding, removing, or updating gate values (boolean, actors, groups, percentages, and expressions). The \FeatureSynchronizer\ handles the granular logic for syncing individual feature gates, including handling legacy empty-group expressions and conditional enablements. The \IntervalSynchronizer\ wraps the main synchronizer to invoke it at configurable intervals (defaulting to 10 seconds), with a TODO note indicating future jitter support to prevent thundering herd issues. These components enable the sync adapter to maintain consistency between local and remote feature flag states.
lib/flipper/adapters/sync · high confidence
Behavioural changes
Add flipper\_properties and refine flipper\_id for ActiveRecord actors
New integration modules for ActiveRecord and Sequel models now expose a \flipper\_properties\ method, which returns the model's class name and all its attributes to support feature flag expression evaluation. For ActiveRecord specifically, the \flipper\_id\ method has been updated to use \base\_class\ when constructing the actor identifier, ensuring correct identification for models using single-table inheritance.
lib/flipper/model · high confidence
Deprecate Flipper::Adapters::Poll::Poller in favor of Flipper::Poller
The adapter-specific poller class has been deprecated and replaced by a top-level Flipper::Poller. Code referencing the old adapter-scoped name will now receive a deprecation warning and continue to work via a shim, but users should migrate to the new top-level class to avoid future removal.
lib/flipper/adapters/poll · high confidence
Fixes Redis adapter compatibility with Rails 7.1 and older Redis clients
The Redis adapter now safely handles connection management across different Redis client versions and Rails environments. Specifically, it resolves a conflict where Rails 7.1's ActiveSupport \Object\#with\ method interfered with Redis clients older than version 4.7.0, which could cause connection blocks to receive \nil\. The adapter now detects the client type and version, using the native Redis \with\ method for compatible versions (\>= 4.7.0) or ConnectionPool instances, and falling back to direct block execution for older Redis clients to ensure stable operation.
_lib/flipper/adapters/redis\shared · high confidence
Flipper UI styles updated to Bootstrap 5.3.3
The Flipper UI public stylesheets have been updated to use Bootstrap 5.3.3, replacing the previous version. This change brings modern CSS variables, updated component styling, and improved responsive behavior to the Flipper interface, ensuring a more consistent and up-to-date visual experience for users managing feature flags.
lib/flipper/ui/public/css · high confidence
Flipper UI switches to Bootstrap 5 and removes jQuery dependency
The Flipper UI frontend has been upgraded from Bootstrap 4 to Bootstrap 5.3.3 and rewritten to remove the jQuery dependency, relying instead on native browser APIs. This change updates the underlying UI framework for components like tooltips, modals, and dropdowns, and modifies the application logic to use vanilla JavaScript for event handling and DOM manipulation.
lib/flipper/ui/public/js · high confidence
Flipper core library restructured with new classes and configuration
The Flipper library has been restructured, introducing new core classes such as Flipper::Actor, Flipper::Adapter, Flipper::DSL, and Flipper::Feature, along with supporting modules like Flipper::Expression and Flipper::Gate. A new Flipper::Configuration class and Flipper::AdapterBuilder provide a more flexible way to configure adapters and middleware. The Rails integration is now handled via Flipper::Engine, which automatically configures the default instance, middleware, and adapters based on environment variables and Rails credentials. Additionally, a new CLI (Flipper::CLI) is introduced for managing features from the command line, and Flipper::Cloud integration is enhanced with new middleware and configuration options. Also in this area: Improved CLI startup reliability and UI encoding safety; Reserved feature name protection and interactive Cloud token prompt; Improved CLI error handling and usage display.
flipper, lib/flipper · high confidence
HTTP adapter refactored with secure debug output and enhanced error reporting
The HTTP adapter has been restructured to improve security and debugging capabilities. A new \Client\ class now handles HTTP requests, including the ability to configure debug output via a configuration hash. To prevent sensitive credentials (such as the Flipper Cloud token and Authorization headers) from being exposed in logs, debug output is automatically redacted. Additionally, the adapter now provides more detailed error messages by parsing and including the response body's message and more\_info fields when an HTTP request fails.
lib/flipper/adapters/http · high confidence
Introduce configurable Flipper UI with read-only mode and feature management controls
The Flipper UI now supports runtime configuration via \Flipper::UI.configuration\, allowing users to enable read-only mode, disable feature creation or removal, and customize UI text (such as the add-actor placeholder). The interface enforces these settings by hiding write controls in read-only mode and displaying specific alerts when feature creation or removal is disabled. Additionally, the UI now includes an Export/Import section in Settings for backing up and restoring feature data, and displays a banner configuration option for site-wide messages.
lib/flipper/ui/views · high confidence
Introduce structured UI action classes for feature management
The Flipper UI now uses dedicated action classes (e.g., ActorsGate, BooleanGate, Feature, Import, Export, CloudMigrate) to handle requests, replacing the previous monolithic controller logic. This change introduces read-only mode enforcement across all mutating actions, enables configuration-driven feature creation and removal controls, adds support for feature descriptions and actor names via configurable sources, and implements file import with size limits and validation. It also adds cloud migration support, a settings page, and compatibility with Rack 2.1+ for static file serving.
lib/flipper/ui/actions · high confidence
Introduces a new, hardened API layer with standardized error handling and secure parameter parsing
The \lib/flipper/api\ location now contains a complete, new API implementation that replaces the previous ad-hoc routing. This includes a new \Action\ base class for handling requests, a \JsonParams\ middleware that hardens parameter parsing against injection and malformed input (including strict validation for mutation requests), and a standardized \ErrorResponse\ module that returns consistent JSON error structures with specific HTTP status codes (e.g., 422 for validation errors). The middleware also supports Rack 3 constants and unescapes feature names from routes to allow slashes in feature names.
lib/flipper/api · high confidence
Refactored expression builder to use a simple proc-based structure
The expression builder in lib/flipper/expression has been refactored to remove unnecessary class references and base classes, simplifying the implementation to a simple proc-based structure. This change restores support for String, Boolean, and Number expressions for casting, ensuring that type-specific comparisons and logical operations (such as equality, inequality, and range checks) continue to function correctly within the flipper expression system.
lib/flipper/expression · medium confidence
Refactored feature flag types into a modular, namespaced structure with Ruby 3.0 support
The feature flag type system has been reorganized into the \Flipper::Types\ module, introducing distinct classes for Actor, Boolean, Group, and Percentage (including \PercentageOfActors\ and \PercentageOfTime\). This change enforces that actors are identified by a \flipper\_id\ method rather than a generic \id\, ensuring consistent string-based identification. Boolean values are now explicitly typecast, and percentage values are validated to be between 0 and 100. The Group type now supports shorthand block notation for single-argument matchers, and the entire implementation is updated to support Ruby 3.0 syntax, including proper handling of keyword arguments in \method\_missing\.
lib/flipper/types · high confidence
Repository modernization and contributor onboarding setup
The repository has been restructured to improve developer experience and onboarding. A new CLAUDE.md file provides comprehensive guidance for AI coding assistants and developers, detailing architecture, testing commands, and release workflows. A new CODE\_OF\_CONDUCT.md establishes community standards. The README has been significantly expanded with installation instructions, usage examples, and links to documentation and Flipper Cloud. Development tooling has been updated with a new Guardfile for automated test running, a .rspec configuration, and a Dockerfile and docker-compose.yml to simplify local environment setup with Redis, MongoDB, and Memcached. The Rakefile now explicitly defines tasks for RSpec, Minitest, and Rails generator tests. Additionally, .gitignore and .codeclimate.yml have been added to manage build artifacts and code analysis exclusions.
(repo-wide) · high confidence
Test coverage
Add test helper for Rails generator tests; Added comprehensive test coverage for Flipper UI actions; Added comprehensive test coverage for core Flipper components; Added comprehensive test suites for new and existing Flipper adapters; Added minitest suite for Flipper adapters; Added shared adapter specification suite; Added shared adapter test suite for Flipper; Added system test for Flipper TestHelp with threaded Capybara drivers; Added test coverage for Flipper API request handling and validation; Added test coverage for Flipper API v1 actions; Added test coverage for Flipper Cloud configuration, DSL, and migration features; Added test coverage for Flipper expression types; Added test coverage for Flipper feature gates; Added test coverage for Flipper model integrations with ActiveRecord and Sequel; Added test coverage for Flipper type implementations; Added test coverage for JSON v1 export functionality; Added test coverage for Memoizer and SetupEnv middleware; Added test coverage for expression builder, integration, and top-level API; Added test coverage for the Flipper Sync adapter components; Added test fixtures for feature flags and environment configuration; Added test infrastructure and shared test helpers; Added test support infrastructure and helpers; Added tests for Flipper Cloud telemetry components; Added tests for Flipper Rails generators; Added tests for Flipper UI configuration, action handling, and utility functions; Added tests for Flipper instrumentation subscribers; Added tests for Gzip and JSON serializers; Added tests for Memory and Noop instrumenters; Added tests for feature gate exclusion in API decorator; Added unit tests for Flipper UI decorators.
Dependencies
Initial dependency manifests for Flipper and its UI assets
This change introduces the foundational dependency configuration for the Flipper gem ecosystem. It adds a Gemfile and 12 gemspec files (including the core \flipper\ gem and adapters like \flipper-redis\, \flipper-active\_record\, \flipper-ui\, etc.), establishing version constraints for Ruby dependencies such as Rails 8, Redis (\< 6), and ActiveRecord (\>= 4.2, \< 9). Additionally, it adds \package.json\ and \package-lock.json\ to manage frontend assets, specifically locking Bootstrap to version 5.3.3 and @popperjs/core to 2.11.8.
(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 43 → 42 (-1.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 64 → 61 (-2.7)
- Architecture 85 → 89 (+4.8)
- Maturity 62 → 57 (-5.0)
- Readiness 57 → 57 (-0.2)
- Security 32 → 28 (-3.9)
- Domain Modelling 100 → 100 (+0.0)
- Accessibility 39 → 42 (+3.2)
- Performance 85 → 85 (+0.0)
Resolved (5)
- Duplicated block (13 lines × 2) (lib/flipper/ui/actions/percentage_of_actors_gate.rb)
- Low cohesion: Moneta (LCOM4 4) (lib/flipper/adapters/moneta.rb)
- Low cohesion: Poll (LCOM4 4) (lib/flipper/adapters/poll.rb)
- Off-boarding risk: anonymized user #1
- Projects may be oversized for their cohesion
New (23)
- Duplicated block (15 lines × 2) (lib/flipper/ui/actions/percentage_of_actors_gate.rb)
- Edited copy of a member (11 corresponding lines) (lib/flipper/adapters/instrumented.rb)
- Edited copy of a member (13 corresponding lines) (lib/flipper/cloud/migrate.rb)
- Edited copy of a member (15 corresponding lines) (lib/flipper/adapters/active_record.rb)
- Edited copy of a member (15 corresponding lines) (lib/flipper/adapters/active_record.rb)
- Edited copy of a member (16 corresponding lines) (lib/flipper/adapters/mongo.rb)
- Edited copy of a member (16 corresponding lines) (lib/flipper/adapters/redis.rb)
- Edited copy of a member (17 corresponding lines) (lib/flipper/adapters/moneta.rb)
- Edited copy of a member (18 corresponding lines) (lib/flipper/adapters/memory.rb)
- Edited copy of a member (18 corresponding lines) (lib/flipper/api.rb)
- Edited copy of a member (21 corresponding lines) (lib/flipper/adapters/mongo.rb)
- Edited copy of a member (9 corresponding lines) (lib/flipper/api/middleware.rb)
- Further sole-owners (lower concentration)
- Low cohesion: CacheBase (LCOM4 5) (lib/flipper/adapters/cache_base.rb)
- Low cohesion: Http (LCOM4 5) (lib/flipper/adapters/http.rb)
- Low cohesion: Memoizable (LCOM4 5) (lib/flipper/adapters/memoizable.rb)
- Low cohesion: Moneta (LCOM4 5) (lib/flipper/adapters/moneta.rb)
- Low cohesion: PStore (LCOM4 4) (lib/flipper/adapters/pstore.rb)
- Low cohesion: Poll (LCOM4 6) (lib/flipper/adapters/poll.rb)
- Low cohesion: Rollout (LCOM4 6) (lib/flipper/adapters/rollout.rb)
- …and 3 more
Changes since last survey
- 81 commits — 81 feature/other, 0 fixes
By area
- lib/flipper — 28 commits
- (repo) — 27 commits
- spec/flipper — 16 commits
- (root) — 5 commits
- .github/workflows — 3 commits
- examples/ui — 1 commit
- test_rails/system — 1 commit
Notable commits
- change: Add SemVer expression for semantic version comparisons
- change: Check bare flipper cloud against the same help as help cloud
- change: Clear Flipper config after each ActiveRecord adapter spec
- change: Declare logger and pstore so flipper loads on Ruby 4 without Rails
- change: Document SemVer nil semantics for Equal and NotEqual
- change: Don't read an option's value as a help flag
- change: Fail comparisons on percentages that can't be read
- change: Fail expression comparisons, not the check, on values that aren't times
- change: Fail expressions, not the check, on property values of the wrong type
- change: Give the system test's browser commands 30 seconds on slow CI runners
- change: Keep read only adapters read only when another adapter wraps them
- change: Keep the example name so the spec doesn't conflict with open branches
- change: Keep the expression gate closed for unknown functions
- change: Keep the sync version apart from feature data
- change: Keep the version flag on the top level command
- change: Let CI use Rack 3
- change: Load ActiveRecord::Base when building the ActiveRecord adapter
- change: Load rack/session with flipper/ui
- change: Make Poll reads cheaper and keep boot polls an interval apart
- change: Make the UI examples boot on Rack 3
- …and 61 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
flippercloud/flipper was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 3afc308c3fdf709d93162adf4972560c46381fc9 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.