Introducing Lapsoss: Vendor-neutral error tracking for Ruby applications

As a Ruby developer, I've worked with countless error tracking solutions over the years. Each one promised simplicity, but delivered vendor lock-in instead. That's why I built Lapsoss - a universal interface for error tracking that works with any backend, including self-hosted solutions like Telebugs.

Why Lapsoss? It's not about fighting vendors

Let me be clear: I'm not fighting against Sentry, Datadog, or any other error tracking provider. I use them personally in production applications, and they serve their purpose well for enterprise teams with specific requirements.

But here's the thing - when I want to spin up a weekend project for some friends, build something for a hackathon, or prototype an idea quickly, I don't want to spend time thinking about which error reporting service is "suitable" for this particular project.

Should I use Sentry's free tier? Will I hit the limits? Should I set up Rollbar? What about that new service everyone's talking about?

I just want errors to show up somewhere, and I want to own that "somewhere."

That's the gap Lapsoss fills - removing the decision fatigue from small projects while keeping the door open to switch providers as your needs evolve.

The problem: SDK proliferation in Ruby applications

Modern Ruby applications often integrate multiple error tracking services across different teams and projects. A typical enterprise setup might look like this:

• Sentry for the main Rails application
• Rollbar for legacy services
• AppSignal for performance monitoring
• Custom logging for specific microservices

Each SDK brings its own API, configuration format, and memory footprint. In Ruby, where classes are loaded permanently, this can add significant overhead - especially when multiple SDKs monkey-patch the same core classes.

The solution: Universal error tracking interface

Lapsoss provides a single, consistent API that works with any error tracking backend:

# Install once
gem 'lapsoss'

# Configure multiple providers
Lapsoss.configure do |config|
  config.use_telebugs(dsn: ENV['TELEBUGS_DSN'])
  config.use_sentry(dsn: ENV['SENTRY_DSN'])
end

# Use the same interface everywhere
Lapsoss.capture_exception(error)
Lapsoss.capture_message("Custom event")

Key benefits for Ruby applications

1. Simplified migration and testing

Want to evaluate Telebugs alongside your current provider? Enable both simultaneously:

Lapsoss.configure do |config|
  config.use_sentry(name: :current_provider)
  config.use_telebugs(name: :evaluation)
end

Compare them side-by-side with real production data, then choose the best fit for your needs.

2. Reduced memory footprint

Instead of loading multiple heavy SDKs, Lapsoss provides lightweight adapters that only load what you actually use.

3. Configuration flexibility

Route errors intelligently based on your requirements:

Lapsoss.configure do |config|
  # Route by environment
  config.use_telebugs(name: :production) if Rails.env.production?
  config.use_local_logger(name: :development) if Rails.env.development?

  # Route by error type
  config.use_sentry(name: :security_alerts,
                    filter: ->(error) { error.is_a?(SecurityError) })
end

Rails-first design with Rails error integration

Lapsoss was built specifically for Rails applications and integrates seamlessly with Rails 7+ error handling. Instead of manually catching exceptions everywhere, Lapsoss hooks into Rails' built-in error reporting system.

This means zero boilerplate in most Rails applications. Rails already knows about your errors - Lapsoss just makes sure they get to the right place.

Perfect integration with Telebugs

Lapsoss was designed with self-hosted solutions like Telebugs in mind. The Telebugs adapter supports all core functionality including user context, tags, and additional metadata - all using the standard DSN configuration format you're already familiar with.

Technical implementation details

Lapsoss uses a clean adapter pattern that makes it easy to add new providers or build custom integrations. Each adapter handles the specifics of communicating with different error tracking backends while maintaining a consistent interface.

Migration guide

From Sentry to Telebugs + Lapsoss

Migration is straightforward: install Lapsoss, update your configuration to use Telebugs instead of Sentry, and replace your capture calls. The real benefit is being able to run both providers simultaneously during the transition to compare them with real production data.

Community and ecosystem

Lapsoss is designed to grow with the community.

Planning to add support for more providers based on community needs.

Getting started

Getting started is simple: add Lapsoss to your Gemfile, configure it with your Telebugs DSN, and you're done. For Rails applications, error reporting happens automatically through Rails.error integration.

Beyond Ruby: Universal error tracking for all languages

The Lapsoss concept isn't limited to Ruby. Telebugs supports multiple languages, and the same vendor-neutral pattern can be applied anywhere - JavaScript, Python, Go, or any language with error tracking needs.

The core principle remains: one interface, any backend.

Perfect for home projects and side hustles

Here's where Telebugs + Lapsoss really shine: simple applications that just need basic error tracking.

When you're building a personal project, side hustle, or small business application, you want to know when things break. But you don't need:

• APM complexity - You're not running a distributed system
• Performance monitoring - Your app fits on one server
• Telemetry collection - You don't need user behavior analytics
• Team collaboration features - It's just you

You just want: "Tell me when my app crashes, and show me the error."

Traditional error tracking services are overkill. They're built for enterprise teams with enterprise budgets. But with Lapsoss + Telebugs:

# Your entire error tracking setup - that's it!
Lapsoss.configure do |config|
  config.use_telebugs(dsn: ENV['TELEBUGS_DSN'])
end

# Rails handles the rest automatically
# Unhandled exceptions → Rails.error → Lapsoss → Telebugs

That's literally it. Rails already catches your exceptions. Lapsoss already subscribes to Rails.error. Telebugs already receives and displays them.

No manual exception handling. No complex dashboards. No team invitations. No usage-based pricing that spikes when your weekend project goes viral.

Just simple, reliable error tracking that you own, with zero boilerplate code.

The future: Vendor-neutral monitoring everywhere

Lapsoss represents my vision for the future of application monitoring: powerful tools without vendor lock-in. By providing a universal interface, developers can:

• Choose the best backend for their needs
• Switch providers without code changes
• Run multiple backends for redundancy
• Build custom solutions on standard interfaces

Combined with Telebugs' self-hosted approach, this gives developers complete control over their error tracking infrastructure - whether it's a Fortune 500 application or a weekend side project.

---

Lapsoss is open source and will remain free forever. It's part of a broader effort to create community-owned tools that serve developers, not vendors.