flippercloud/flipper

Flipper is a Ruby feature flag library that enables granular control over feature rollouts through boolean, actor, group, percentage, and expression-based gates. It supports persistence via multiple storage adapters, including Redis, MongoDB, ActiveRecord, and HTTP, and provides a web UI and REST API for management. The system also includes capabilities for cloud synchronization, telemetry, and request-scoped caching to ensure reliable and performant feature evaluation.

21 changes.

This period focused on a comprehensive restructuring of the Flipper core library, introducing a modular architecture with dedicated require files, new DSL-based expression gates, and a flexible adapter system. The work established foundational infrastructure including dependency manifests, extensive test coverage, and instrumentation capabilities to support the new API and improve developer experience.

25 changes.

This period focused on introducing a configurable web UI, a hardened API v1, and new Rails generators to streamline Flipper integration. The work included modernizing the frontend by switching to Bootstrap 5 and removing jQuery, while simultaneously restructuring internal logic into dedicated action and decorator classes. Comprehensive test coverage was added for the new UI, API, and adapter components to ensure stability across the expanded feature set.

30 changes.

This period focused on establishing robust Flipper Cloud connectivity through new configuration, webhook synchronization, and telemetry systems, alongside a comprehensive rewrite of the expression engine to support complex logical and time-based rules. Significant infrastructure work included adding a sync adapter for local-remote state consistency, JSON export/import capabilities, and extensive CLI and Rails generator tooling. The effort was heavily supported by broad test coverage and performance benchmarking to ensure stability across these new features.

New example scripts (basic.rb and internals.rb) have been added to the examples/mongo directory to demonstrate how to use the Flipper MongoDB adapter. These examples show how to configure the connection via the FLIPPER\_MONGO\_URL environment variable, enable features for actors and groups, and inspect the underlying adapter storage.

examples/mongo · high confidence

New example scripts have been added to the \examples/redis\ directory to demonstrate how to use the Flipper Redis adapter. The \basic.rb\ script shows simple feature enablement and disabling, while \internals.rb\ provides a deeper look at registering groups, actors, and percentage-based features, including inspecting the underlying Redis keys and data structures.

examples/redis · high confidence

New example scripts have been added to the \examples/sequel\ directory to demonstrate how to use the Flipper library with the Sequel database adapter. The \basic.rb\ script shows how to initialize an in-memory SQLite database, run the necessary migration, and toggle a feature flag. The \internals.rb\ script provides a more comprehensive demonstration, including registering groups and actors, enabling percentage-based gates, and inspecting the underlying feature and gate data stored in the database.

examples/sequel · high confidence

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

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

Flipper now includes two new instrumenter implementations: a Memory instrumenter that stores all instrumentation events in memory (useful for testing and debugging) and a Noop instrumenter that performs no operations. The Memory instrumenter captures event names, payloads, and results, allowing users to query events by name or reset the stored events. The Noop instrumenter provides a null implementation for cases where instrumentation is not needed.

lib/flipper/instrumenters · high confidence

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

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

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

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

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 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

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

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

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

Added a new telemetry subsystem for reporting feature usage metrics to the Flipper Cloud. This includes a backoff policy with configurable timeouts and jitter for retrying failed submissions, a metric storage component for buffering counts, and a submitter that gzips and posts metric data to the /telemetry endpoint. The system integrates with the cloud configuration to instrument telemetry errors and retries, ensuring visibility into submission health.

lib/flipper/cloud/telemetry · high confidence

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

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

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

Added a suite of example scripts in the examples/active\_record directory to demonstrate how to use the Flipper Active Record adapter. These include a setup script (ar\_setup.rb) that defines the required database schema and model integration, a basic usage example, a caching example using ActiveSupport::Cache, an internals inspection script, and a migration guide for converting individual actor flags to group-based flags.

_examples/active\record · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

The examples directory has been completely refreshed to showcase the library's updated API. Basic usage now defaults to the Memory adapter and demonstrates the new \Flipper.configure\ setup. The legacy DSL methods (such as \bool\, \actors\, \time\, and \percentage\_of\_actors\) have been removed in favor of a new expression-based system, with new examples illustrating \enable\_percentage\_of\_actors\, \enable\_percentage\_of\_time\, and complex boolean/logical expressions (AND/OR/NOT) for feature gating. Additional examples cover new capabilities including dynamic group lookups, actor mirroring between adapters, feature importing, instrumentation via ActiveSupport::Notifications, and strict adapter validation.

examples · high confidence

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

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

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

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

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.

lib/flipper · high confidence

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

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

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

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

The expression evaluation logic has been refactored to replace the previous class-based hierarchy with a simpler structure using procs and a builder pattern. This change introduces a new \Expression::Builder\ module that provides a fluent API for constructing expressions (e.g., \any\, \all\, \equal\, \greater\_than\) and a \Constant\ class for handling literal values like strings, numbers, and booleans. The primary benefit for users is improved performance through reduced object allocation (specifically avoiding Hash allocations in constants) and a cleaner, more maintainable codebase for defining feature flag conditions.

lib/flipper/expression · high confidence

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

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

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.

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

• CAI 62 → 53 (-9.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 98 → 94 (-4.5)
• Architecture 100 → 63 (-36.7)
• Maturity 63 → 63 (+0.0)
• Readiness 50 → 53 (+2.3)
• Security 65 → 75 (+10.1)
• Domain Modelling 100 → 100 (+0.0)
• Accessibility 43 (new)

• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Low CVE: [GHSA redacted] (Gemfile)
• Low CVE: [GHSA redacted] (Gemfile)
• Off-boarding risk: anonymized user #1

• Ambiguous naming for collection retrieval. any and all are often confused in Ruby APIs (where any? is a predicate). It is unclear if any returns a boolean or a collection, and if all returns a collection or a boolean. Given Flipper.groups() exists, these likely return feature collections, but the names are non-standard and potentially misleading compared to features() used in adapters.
• Asymmetric boolean query methods. Most adapters and internal logic use a single get or enabled? style lookup, but the top-level Flipper API exposes two separate methods for checking state. This forces callers to choose the correct method based on the expected outcome rather than querying the state directly.
• FileTooLong: js/jquery-3.6.0.slim.js (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• Inconsistent entity retrieval naming. Team uses find(name) which implies a database lookup by primary key or unique attribute, while Flipper uses group(name) which is a direct accessor. If Team is a domain entity managed by Flipper, the retrieval method should align with the core API's group or feature naming convention for consistency.
• Off-boarding risk: anonymized user #1
• Projects may be oversized for their cohesion
• jquery-3.6.0.slim.access (cognitive 24) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.adjustCSS (cognitive 21) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.adjustCSS (cyclomatic 22) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.boxModelAdjustment (cognitive 21) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.buildFragment (cognitive 39) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.buildFragment (cyclomatic 20) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.domManip (cognitive 55) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.domManip (cyclomatic 26) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.getWidthOrHeight (cyclomatic 17) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.jQuery.Callbacks (cognitive 39) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.jQuery.Callbacks (cyclomatic 31) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.leverageNative (cognitive 19) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.on (cognitive 16) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)
• jquery-3.6.0.slim.showHide (cognitive 24) (lib/flipper/ui/public/js/jquery-3.6.0.slim.js)

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

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.