DEV Community: Razvan

Your product can answer questions about itself now

Razvan — Sat, 27 Jun 2026 13:07:39 +0000

Ask your product anything, in plain English, and it answers. Then it keeps watching and tells you the moment the answer changes.

That's the whole thing. It sounds small until you sit with what it replaces.

Think about the last time you needed to know something about your own product. Whether the feature you shipped is actually being used. Whether the customer about to churn still logs in. How many people hit an error today. The answer always existed somewhere inside the system. You just couldn't get it without interrupting the one person who knows where to look, and waiting.

That waiting is a tax every company pays and nobody notices. The founder waits a day for the analyst's dashboard. Support waits twenty minutes per ticket for an engineer. Sales waits for someone to check whether the dying account is even awake. The product had the answer the entire time. It just couldn't speak.

Now it can.

You ask. It watches. It tells you.

In EZLogs you pin a question to your product, written exactly how you'd say it out loud:

"Tell me when a trial account goes quiet for 3 days."
"Is the bulk-export feature failing for anyone?"
"Tell me when a new user registers."

No metric to name. No query to write. No threshold to set. No dashboard to build first. You type the sentence, and the product takes it from there.

From that moment it's watching. And when the answer changes, it comes to you, in plain language, with the story already written:

Acme Corp went quiet. Trial, day 9. Zero activity for 3 days, then 4 failed logins this morning.

Bulk-export is failing for 5 people. 47 ran it this week. 5 failed, all on exports over 10,000 rows, the same step every time.

A salesperson catches the churning account while there's still time to call. A designer learns their feature is quietly broken for everyone on big files, without instrumenting a single line. A founder gets the business in a sentence every Monday, and an off-cycle nudge the moment something moves. Same engine. Everyone in the company finally on speaking terms with the product they're building.

Every number shows its receipts

Here's the part that makes it trustworthy instead of just clever.

Every figure in every answer clicks straight back to the real events behind it. "3 checkouts failed for Acme today" takes you to those exact three checkouts. "47 people ran bulk-export" takes you to the 47. The claim and the proof are always one click apart.

These numbers are not an AI guessing what probably happened. They are counted from what actually happened. The whole alert is one click that drops you exactly where the evidence lives: a trend alert lands you on the trend, a failure alert on the failures, a "this account went silent" alert on that account's live page. One headline, one click, the full story waiting on the other side.

The AI does exactly one job, at the edges: it turns your sentence into something the system can answer, and it phrases the result back in plain English. It never decides what's true. The truth is a fact, counted, with its receipts attached. The AI translates, it never judges, and that is what lets a non-engineer trust the answer the way they'd trust a number an engineer hand-pulled for them.

Why this matters

Datadog tells your engineers when a number crosses a line they configured. This lets anyone in your company ask the product a question in human words and get a true, cited, plain-language answer that keeps watching for them.

Different audience. Different promise. A different relationship with the software you build.

I think the products that win the next few years won't feel like magic because of the AI. They'll feel like magic because they finally tell you the truth, in your own words, the moment it changes. That's what we shipped. It's live in EZLogs today.

Try it

There's a free tier, no card. If you've got a Rails or Next.js app, point the agent at it, pin a question, and see if the answer holds up when it fires.

https://ezlogs.io

If you pin something and the alert comes back wrong, or worse, comes back confidently fake, tell me. That's the one bug this whole thing exists to not have.

Razvan

How to give Claude (or Cursor) access to your Rails app's activity logs

Razvan — Sun, 14 Jun 2026 09:08:20 +0000

Ask Claude this, today, with no setup:

"What did user 4421 do in our app yesterday?"

You will get an answer. It will be confident, specific, and completely made up. Claude has no access to your production database. So it does what a language model does when it has no facts: it pattern-matches what an answer should look like and hands you fiction in a calm voice.

That is the whole problem. Not that the model is dumb. That it is answering a question about your data without your data.

The Model Context Protocol fixes this, if you point it at the right source. This post is about what MCP is for a Rails dev who hasn't wired one up yet, why you'd want one over your app's activity log, and how I built the EZLogs MCP server so the answer is the boring true one instead of the confident fake one.

What MCP actually is

MCP is a small open protocol from Anthropic. It lets an AI client (Claude Desktop, Cursor, your internal copilot) call out to a server you control and ask for data, mid-conversation, before it answers you.

That's it. It is not a framework. It is not a model. It is a way for the model to say "hold on, let me go look" instead of guessing.

A server exposes three things:

Tools the AI can call, like "find actions by this user between these dates"
Resources it can read, like "the 50 most recent significant actions"
Prompts it can use, like "draft an incident report for this action"

The AI decides when to call them. You decide what they return. The protocol is just JSON-RPC over HTTP at a single endpoint.

Why your activity log is the right thing to expose

You could point an MCP server at your raw database. People do. It goes badly for the same reason raw logs go badly for humans: the model gets gid://app/Order/4421, a pile of foreign keys, and a Sidekiq job class, and now it has to do the translation. So it guesses at the join, guesses at what the columns mean, and you are back to a confident fake answer, just one layer deeper.

An activity log is already the translated layer. One row per user action, correlated across HTTP, background jobs, and database changes, with a human-readable name. "User 4421 tried to ship order #4421, address validation failed, the retry job ran three times and gave up." When the model reads that, it has nothing left to invent. The facts are already facts.

So the activity log is the better MCP source precisely because the hard part, correlation and naming, was done before the model showed up.

The part that matters: deterministic, not generated

Here is the line I care about most, and the one I'd push back on hardest if you were evaluating any tool in this space.

The translation in EZLogs has no model in it.

The cards your team reads, and the data the MCP server returns, are produced by correlation plus templates. Same events in, same sentence out, every time. The action stream is folded into state with pure functions that never call an LLM and never write to the database, and every value carries the IDs of the specific events it came from. You can click any number back to its evidence.

That means when your AI asks the EZLogs MCP server "what happened to order 4421," the rows it gets back are deterministic facts, not a second model's opinion. Your AI narrates them. Our side never narrates. We hand over structured data with citations; the model turns it into a sentence and spends its own credits doing it.

This is the difference between "the AI made up an answer" and "the AI read the answer." A year into shipping AI features, that is the distinction CTOs are actually asking about. Where do the facts come from, and can I trace them.

What the EZLogs MCP server exposes

Six query-only tools. Every one of them reads. None of them writes back into your app, ever. That is a permanent design rule, not a current limitation: EZLogs holds no write credentials into your systems, so the blast radius of the whole thing is read-only.

find_actions: search the activity log by actor, entity, outcome, date, significance
get_action: one action by id, with its full underlying event stream
actor_timeline: one user's or agent's recent actions plus their current state
entity_timeline: one order, account, document, whatever, plus its current state
compare_actions: line up two to five actions and find where they diverged
top_lists: rank actors and entities by activity in a window

find_actions and top_lists are on the free tier. The rest are paid. MCP usage itself is unlimited on every paid tier, because the AI spends its own credits to narrate; we just deliver the rows.

There are also read-only resources (ezlogs://recent, ezlogs://actor/{id}, and friends) and prebuilt prompts (summarize_day, investigate_failure, incident_report) for the common questions.

Wiring it up

Two steps. Get events flowing, then connect your AI.

Rails app (the gem captures HTTP, Sidekiq, and ActiveRecord with no manual middleware):

# Gemfile
gem 'ez_logs_agent'

bundle install
rails generate ez_logs_agent:install

# config/initializers/ez_logs_agent.rb
EzLogsAgent.configure do |config|
  config.server_url    = "https://app.ezlogs.io"
  config.project_token = "ezl_your_key_here"
end

Next.js app, if that's your stack instead or as well, is npm install ezlogs-nextjs plus a small instrumentation.ts. Both agents emit the identical wire format, so the server treats them as one source.

Then connect Claude or Cursor. For Cursor, add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "ezlogs": {
      "url": "https://app.ezlogs.io/mcp",
      "headers": { "Authorization": "Bearer ezl_your_key_here" }
    }
  }
}

For Claude Desktop on macOS it's one command, which backs up your existing config and merges in the EZLogs entry:

curl -fsSL https://app.ezlogs.io/install/claude-desktop.sh | sh

Quit Claude, reopen, and ask it "what happened yesterday?" This time it goes and looks.

What it isn't

It isn't a metrics platform and it isn't an APM. It doesn't watch CPU or page you at 3am. Datadog watches your infrastructure; this explains the work your app did, in language a support person can read.

It also isn't an AI tool that translates your logs. The AI is on your side of the connection, the one asking questions. The translation underneath is deterministic and the same with the AI turned off. If removing every model from the path would break the answer, the design would be wrong. It doesn't.

Try it

There's a free tier, no card, and the MCP server is part of it. If you've got a Rails or Next.js app and an AI client you keep wanting to ask about production, point one at the other and see if the answer holds up.

https://ezlogs.io

If you wire it up and the answer comes back wrong, or worse, comes back confidently fake, tell me. That's the one bug this whole thing exists to not have.

Razvan

Every engineering team has a translator. I wrote the thing that translates

Razvan — Fri, 05 Jun 2026 13:59:07 +0000

Every engineering team I've worked on has had the same unspoken job title. Nobody's hired into it. It just lands on whoever's been there longest and answers Slack the fastest.

The translator.

Someone in support pings: "what happened to order #4421?" The translator opens five tabs. Application logs. Sidekiq dashboard. Database. A few greps. Twenty minutes later they paste back: "shipping address validation failed because the customer's postcode hit the new regex, then the retry job ran 3 times, then we rolled back the order."

The support person says thanks. The customer gets an answer. The translator goes back to whatever they were doing before they got pulled out of focus.

This is the actual cost of "observability." Not the bill from Datadog. The bill from your senior engineer's attention.

What logs are vs. what humans need

Logs are designed for the computer that wrote them. Stack traces. Request IDs. Job classes. Foreign keys. A line in a log file is a diff against some piece of internal state, formatted so the system can find it later. That's correct. That's what logs are for.

It's also why nobody outside engineering can read them.

A product manager doesn't care that Sidekiq::Worker#perform ran with args=["gid://app/Order/4421", "ship"]. They care that the shipping label generation for Razvan's order failed because the address didn't validate. Same event. Two completely different representations.

The gap between those two representations is where the translator lives.

ezlogs is the translator

I built ezlogs (a Ruby gem and Next.js companion) because I was tired of being the translator. The premise is small. The gem captures three things you already have:

HTTP requests (what users and external systems asked for)
Background jobs (what the system did in response)
Model callbacks (what changed in the database)

Then it correlates them into a single "action" with a human-readable name. Not "POST /orders/4421/ship returned 422." Instead: "Razvan tried to ship order #4421. Address validation failed. The retry job ran 3 times and gave up."

Same data. The pipeline expands GIDs into names, groups events that share a correlation ID, and renders a deterministic sentence from a template. No model in the loop. The output is reproducible.

What it isn't

It isn't a metrics platform. It doesn't replace Datadog or your APM. It doesn't watch CPU. It doesn't page you at 3am.

It also doesn't write back into your app. No "pause" buttons. No approval queues. No webhooks. The agent reads. That's it. If you want to act on what ezlogs sees, your existing ops tooling does the writing. That's deliberate. A read-only product has a tiny blast radius and a tiny security review.

The job is to explain. The job is to make the activity log something a support person, a PM, or a founder can read without asking an engineer for help.

The boring middle

ezlogs is not an "AI translation tool for logs." The translation is deterministic. Templates plus correlation, same input in, same sentence out, no model in the loop. AI summaries are an optional paid add-on, off by default. The free tier already includes the activity log and an MCP server so your AI agents (Claude, Cursor, internal copilots) can query what happened.

The actual work has been correlation. Making sure the Sidekiq job that ran 4 seconds after the HTTP request gets stitched to that request. Making sure a GlobalID in a job arg resolves back to "User #42 (Razvan)" instead of gid://app/User/42. Making sure the same event captured by the Ruby agent and the Next.js agent produces byte-identical wire format on the server.

None of it demos well. All of it has to be right.

Where it is

ez_logs_agent the Ruby gem is on RubyGems. The Next.js companion is on npm. The hosted dashboard is live at ezlogs.io. Free tier includes the deterministic activity log and the MCP server. Sign up, point an agent at your app, see what it has been doing.

If you want to try it:

ezlogs.io (free tier, no card)
ez_logs_agent (Ruby gem)
ezlogs-nextjs (npm)

If you've ever been the translator on your team and want to stop, say hi.

Razvan