Exception Monitoring Without the Sentry Bill

April 2, 2026 · 8 min read · Depify Team

Most teams run two separate tools for understanding production failures. An API monitoring service tells you an endpoint is down. A separate exception tracker like Sentry or Honeybadger tells you why. That is two dashboards, two billing accounts, and zero correlation between the alert that says "your API is failing" and the stack trace that explains what caused it.

Depify now includes exception monitoring as a built-in module. Track application errors with stack traces, breadcrumbs, and automatic issue grouping, all inside the same platform you already use for API monitoring, webhooks, and feature flags.

The Problem with Separate Error Tracking

Sentry Team starts at $26 per month for 50K errors. Honeybadger Team is also $26 per month. Both are good tools. But adding them to your stack introduces real friction.

The fundamental problem is not with Sentry or Honeybadger as products. It is that error tracking lives in a silo, disconnected from the rest of your operational tooling.

How Depify Exception Monitoring Works

The exception monitoring module follows a straightforward flow. Create a project, get a DSN, and start sending errors.

Automatic Issue Grouping

Every incoming exception is fingerprinted using the exception class, message pattern, and top stack frames. Similar errors are automatically grouped into a single issue, so a NoMethodError that fires 2,000 times shows up as one issue with an event count, not 2,000 separate entries.

Stack Trace Viewer

Each event includes a full stack trace with expandable frames. Click any frame to see the source context: the line that raised, plus surrounding lines for quick orientation. Application frames are highlighted and sorted to the top. Library and framework frames are collapsed by default.

Breadcrumbs Timeline

Breadcrumbs capture what happened in the moments leading up to the crash. HTTP requests made, database queries executed, log messages emitted, user actions taken. The timeline is displayed chronologically alongside the stack trace, giving you the full narrative of the failure.

Issue Lifecycle

Mark an issue as resolved. If the same fingerprint appears again, Depify automatically reopens it and alerts you to the regression. No manual tracking required.

What Makes It Different

Getting Started

Create an exception monitoring project in your Depify dashboard. You will receive a DSN URL that looks like this:

https://exc.depify.io/api/v1/ingest/YOUR_PROJECT_DSN

Send exceptions to this endpoint as a JSON POST. Here is how it looks in Ruby and JavaScript.

Ruby

require "net/http"
require "json"

DSN = "https://exc.depify.io/api/v1/ingest/dpf_exc_a1b2c3d4"

def report_exception(error, context = {})
  payload = {
    exception: {
      type:    error.class.name,
      value:   error.message,
      stacktrace: error.backtrace&.map { |frame|
        file, line, method = frame.match(/(.+):(\d+):in `(.+)'/)&.captures
        { filename: file, lineno: line.to_i, function: method }
      }
    },
    breadcrumbs: context[:breadcrumbs] || [],
    tags: context[:tags] || {},
    environment: ENV["RAILS_ENV"] || "production",
    timestamp: Time.now.iso8601
  }

  uri = URI(DSN)
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  req = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
  req.body = payload.to_json
  http.request(req)
end

# Usage
begin
  process_payment(order)
rescue => e
  report_exception(e, tags: { module: "payments", order_id: order.id })
  raise
end

JavaScript (Node.js)

const DSN = "https://exc.depify.io/api/v1/ingest/dpf_exc_a1b2c3d4";

async function reportException(error, context = {}) {
  const payload = {
    exception: {
      type: error.name,
      value: error.message,
      stacktrace: error.stack?.split("\n").slice(1).map(line => {
        const match = line.match(/at (.+?) \((.+?):(\d+):\d+\)/);
        return match
          ? { function: match[1], filename: match[2], lineno: parseInt(match[3]) }
          : { filename: line.trim() };
      })
    },
    breadcrumbs: context.breadcrumbs || [],
    tags: context.tags || {},
    environment: process.env.NODE_ENV || "production",
    timestamp: new Date().toISOString()
  };

  await fetch(DSN, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload)
  });
}

// Usage
app.post("/webhooks/stripe", async (req, res) => {
  try {
    await handleStripeEvent(req.body);
    res.sendStatus(200);
  } catch (err) {
    await reportException(err, {
      tags: { module: "webhooks", provider: "stripe" },
      breadcrumbs: [
        { type: "http", message: "POST /webhooks/stripe", timestamp: Date.now() }
      ]
    });
    res.sendStatus(500);
  }
});

The payload structure is intentionally simple. No proprietary envelope format. Any HTTP client in any language can send events.

Pricing Comparison

Here is how Depify exception monitoring stacks up against dedicated error tracking tools.