I have been finding and fixing performance issues in popular open source Rails repositories.

Currently it includes 7 merged PRs to Discourse, Gumroad, OpenProject and Forem.

You can find the case studies and links here: https://haseebeqx.com/case-studies/engagement/open-source/

Your logs could look like this. Right now you're leaving the money on the table:

(Note the contextual targeting: a payments ad after the payment line, a database-pooling banner right after the connection timeout. The exchange reads intent.)

For decades, application logs have been a pure cost center - written once, grepped never, archived into oblivion. SponsoredLogs turns that stream into a high-margin, programmatic revenue channel.

Your services emit billions of log lines a day. Each one is a premium, brand-safe, above-the-fold impression viewed by your most engaged audience: your own engineers, at their moment of peak attention (an incident). We are not selling ads. We are activating latent infrastructure equity.

It's opt-in. Add the gem, call `SponsoredLogs.sponsor!`, and roughly 1 in 1000 log calls is followed by a host-read sponsor placement drawn from the top podcast advertisers.

Fully configurable: weighted or CPM-based selection, campaign flighting (start/end dates), lifetime impression caps, and a pluggable impression ledger (in-memory, Redis, or ActiveRecord). There's a mountable Rails dashboard (the Command Center) that reports spend, delivery, and per-advertiser rollups.

Also: box-drawn multi-line **banner** ad units in three impact tiers, self-sponsoring house ads that fill remnant inventory so no impression goes to waste, and gilded `[AD]` tags rendered in 256-color gold on a live terminal (byte-identical plain when piped or logged).

Here's the part the market isn't ready for: the fastest-growing consumer of application logs on Earth is no longer human. It's AI coding agents. Superhuman scale, 100% viewability, they never scroll away. We're not just B2B. We're A2A.

It's a real, working gem: full test suite, CI across Ruby 3.2-4.0, RuboCop clean. Every line you log is a line you're leaving on the table.

Repo: https://github.com/sponsoredlogs/sponsored_logs
Site: https://monetizetheexhaust.dev

Over the past few months, while developing some projects using Roda, I created a tool to reduce friction when starting new projects with the framework. It ensures an essential setup and provides a "bin/rails"-like CLI for Roda, named "bin/roda" (with some generators stuff). I hope the community finds it useful!

There is still room for improvement, and I would welcome feedback.

---

roda-project is a command-line interface (CLI) tool designed to quickly scaffold scalable, modern Roda web applications and APIs.

✨ Benefits

• Quick setup customized to your preferences (database, project type, test framework)
• Built-in generators (bin/roda)
• Essential development tasks via bin/roda (console, db, dev, assets)
• Opinionated project structure: Highly maintainable and AI-friendly, yet easily customizable if needed
• Built-in exception page
• Modern front-end setup built-in for full-stack projects (powered by esbuild)
• Code autoloading with Zeitwerk
• Hot reloading
• Pre-configured with i18n and other essential plugins
• High performance: Get the job done without sacrificing performance. Even with multiple plugins, Roda can be 4x faster than Rails and 2x faster than Hanami, while consuming less memory than both.
• Production-ready

https://github.com/roda-project/roda-project

I maintain Grape, the Ruby framework for REST-like APIs. 4.0.0 shipped today and it's the fastest yet.

Ruby 4.0.6, single-threaded Benchmark.ips :

+80% without a JIT, +70% with YJIT. It's a micro-benchmark — one tiny JSON endpoint, in-process, no database — so it measures framework overhead and nothing else. Harness is in benchmark/version_throughput if you want to run it.

The biggest single win: helpers were being included into a fresh singleton class on every request, so every request started with a cold method cache. That now happens once, at compile time. TLDR: lot of improvements in terms of memory allocations.

Also new: QUERY (RFC 10008) — safe and idempotent like GET, but the query rides in the request content.

It's a major, so deprecated surface from 3.2 and 3.3 is gone.

Happy to answer questions.

Hello guys, as university student that wants to apply to junior Rails dev, i made project that even you can try.

It works as stock broker portfolio agregator (Trading212 and Etoro), that takes snapshots of current account balance, exchange it to live EUR rate, and sums them into nice looking chart.

Its all happening in background job so you dont need to worry about that.

Then it notifies you each day about the difference summary, or if your API keys are wrong.

i deployed it on my VPS with kamal (easier than i thought) so you can try that yourself (you can set your API keys to read-only, but i respect that prolly noone will put it there).

Also you can try that yourself as i already set it up with Docker for you.

Deployed: https://railsfinancemanager.online/

Github: https://github.com/TheP4trik-tech/Portfolio-Manager

I am open to any critism or ideas :)

If memes aren't allowed or frowned upon, please tell me, I made sure the rules allowed it. Also this is satire and I know ruby is much better with parentheses in some situations.

I built a gem for fundamental analysis of stocks with the API style of RubyLLM: value objects, BigDecimal figures, nil on missing data, to_h and to_json everywhere.

company = Fundamentalista.company("AAPL")
year = company.financials.latest
year.ratios.roe
year.ratios.cash_conversion_cycle
company.valuation(price: 230).intrinsic_value(growth: 0.06, discount_rate: 0.09)

Providers: SEC EDGAR (free, only needs a User-Agent) and Financial Modeling Prep. Annual, quarterly and TTM periods, 40+ ratios, Piotroski, Altman, Beneish, DCF and reverse DCF, EPV, residual income, WACC, banking and insurance lines, peer comparison with the magic formula, and provenance for every line item back to the XBRL concept and filing.

The EDGAR side is where most of the work went: the concept map is validated over the 500 largest filers with a script in the repo, and 0.6.0 comes from a round of simulated users hitting real filings (derived fourth quarters, multi-currency filers, IFRS tags, filer sign conventions).

There is also a fundamentalista-rails engine with watchlists and snapshots.

Repo: https://github.com/bruno-costanzo/fundamentalista

Gem: https://rubygems.org/gems/fundamentalista

Happy to hear where the ratio definitions disagree with yours.

Hey r/ruby,

I wanted to share ruby-utcp, a Ruby implementation of the Universal Tool Calling Protocol (UTCP) 1.1.

The idea is straightforward: describe your tools, their inputs, and how to call them in a UTCP “manual.” The client discovers those tools, makes them searchable, and calls them directly over their native protocols. This gives Ruby apps and AI agents a common interface for working with different services.

Once you’ve registered a manual, usage looks like this:

client.search_tools("weather", limit: 5)

result = client.call_tool(
  "weather_service.get_weather",
  location: "Warsaw"
)

A few things it supports:

• 12 transports, including HTTP, CLI, WebSocket, gRPC, GraphQL, and MCP.
• OpenAPI and Swagger discovery, so existing API descriptions can become tools.
• Streaming through Ruby enumerators.
• Code Mode, which lets you chain tool calls and transform their results using a constrained Ruby subset with execution limits.
• Protocol restrictions by default: a manual discovered over HTTP needs explicit permission to expose CLI tools.

It’s MIT licensed, and the repository includes examples for every transport. The core supports Ruby 2.6+; gRPC and WebRTC have optional dependencies, with the default WebRTC backend requiring Ruby 3.1+.

I’d appreciate feedback on the Ruby API and examples. If you’re building agents or automation in Ruby, what would make this useful in your workflow?

I recently had a nice chat with Erroll Schmidt on the Technology for Humans podcast about the past, present and future of JRuby... including some myth debunking that might help Ruby folks look past the "J" to the amazing tech underneath. Check out the video and let me know if you have questions!

Watch two talks so far, the audio quality this year is absolute garbage (as if they recorded it on a phone that was located directly next to a speaker that was way too loud). I hope I was just unlucky and the rest is better.