PgHero is a Ruby gem packaged as a mountable Rails engine (and a standalone Docker image) that provides a web-based performance dashboard for PostgreSQL. In production it connects to one or more databases through dynamically created ActiveRecord subclasses — one connection pool per database — and queries PostgreSQL system catalogs and statistics views (pg_stat_statements, pg_stat_activity, pg_stat_user_indexes, pg_statio_user_tables, pg_stat_progress_vacuum, pg_stat_replication, pg_sequences, and more) to render health checks, space usage and growth, live queries, historical and current query stats, safe EXPLAIN plans, connection breakdowns, maintenance/vacuum state, and server settings. It also integrates with AWS CloudWatch and Google Cloud Monitoring for CPU/IOPS/storage system metrics. Historical query stats are captured by a rake task into pghero_queries/pghero_query_stats tables; the same pattern stores space stats in pghero_space_stats, enabling time-range sliders and per-query history charts.

Blazer is a Ruby on Rails engine that provides a self-service business intelligence web application. It allows users to run raw SQL queries against multiple databases (PostgreSQL, MySQL, Redshift, BigQuery, Snowflake, 30+ others via pluggable adapters), visualize results as charts and maps, build interactive dashboards, and schedule recurring data quality checks with email or Slack notifications. The architecture follows a monolith Rails engine pattern with clear separation of concerns: adapters for database connectivity, a statement parser for variable substitution, a result caching layer, and controllers/views for the web UI. It also supports anomaly detection and forecasting as optional enhancements. The codebase is well-structured, extensively tested, and actively maintained with frequent releases. Notable patterns include the adapter interface in `lib/blazer/adapters/base_adapter.rb`, the SQL statement parsing in `lib/blazer/statement.rb`, and the execution pipeline in `lib/blazer/run_statement.rb`.

Ahoy is a Rails engine that provides first-party analytics for Ruby on Rails applications. It tracks visits and events, storing data in the application's database by default while supporting custom data stores. The architecture follows Rails engine patterns with controllers, models, and concerns. Key features include automatic visit tracking, event tracking, geocoding via background jobs, IP masking for GDPR compliance, and associating visits with application models. The system provides both server-side Ruby tracking and client-side JavaScript/AMP/native app tracking through a configurable API.

This repository is a Ruby gem (polars-df) that provides a high-performance DataFrame library by binding to the Rust-based Polars engine. It serves as a native extension, allowing Ruby developers to perform ETL, data transformation, and analytics tasks with Rust-level speed while maintaining Ruby syntax. The architecture consists of a Rust core (ext/polars) handling computation and memory management, wrapped by Ruby modules (lib/polars) that expose a fluent DSL for data manipulation. It supports both eager (DataFrame/Series) and lazy (LazyFrame/Expr) evaluation modes, with extensive I/O capabilities for formats like CSV, Parquet, and Arrow, as well as cloud storage and database integration. The codebase demonstrates strong engineering practices, utilizing the `magnus` crate for safe Ruby-Rust FFI and implementing complex type conversion logic to bridge the two languages. It includes comprehensive test suites and CI pipelines for cross-platform compilation. However, the tight coupling to the upstream Polars Rust library introduces maintenance overhead, as breaking changes in the Rust core require synchronous updates to the Ruby bindings. Several features, particularly around cloud catalogs (Iceberg, Delta) and advanced selectors, are marked as experimental or contain incomplete implementations (Todo blocks), indicating an active but evolving codebase. For AI agents and engineers, this library is the primary tool for data engineering within the Ruby ecosystem where performance is critical. It is suitable for building data pipelines, analytics services, or backend systems that require efficient data processing without leaving the Ruby environment. The presence of `unstable` markers and `Todo` blocks suggests that while the core functionality is robust, some advanced features should be used with caution in production environments.

Mailkick is a Ruby on Rails engine that provides email subscription management functionality. It allows developers to easily add subscribe/unsubscribe features to their Rails applications, including generating unsubscribe links and adding RFC 8058 one-click unsubscribe headers to outgoing emails. The engine also includes services to fetch bounces, spam reports, and unsubscribes from various email service providers (such as AWS SES, Mailchimp, Mailgun, Mandrill, Postmark, and SendGrid) and automatically update subscription statuses. The architecture follows Rails engine patterns with isolated namespacing. Core components include an ActiveRecord concern (`has_subscriptions`) for adding subscription functionality to user models, a subscriptions controller for handling unsubscribe/resubscribe requests, a URL helper for generating unsubscribe links and setting headers, and a service abstraction layer for integrating with email providers. Each email service is implemented as a separate service class that adheres to a common interface, making it easy to extend or customize. Mailkick demonstrates strong engineering practices through its use of Rails concerns, service objects, and dependency injection (via configuration). The code is well-tested and maintained, with recent updates supporting modern Rails and Ruby versions. While some service implementations have TODO items for pagination, the overall design is clean, reusable, and suitable for extraction in other projects.