← Back to Blog

Telesink ActiveJob Integration

Kyrylo Silin
Kyrylo Silin
Telesink founder

I’m a Rails developer through and through. Telesink itself is built in Ruby on Rails. For background jobs I’ve been using Solid Queue together with Mission Control, and I absolutely love it.

Mission Control is fantastic. It gives me job history, retries, errors, and useful performance details. It has become part of my Rails workflow.

There was just one thing missing: real-time visibility.

I would enqueue jobs, go about my day, and later wonder: did they run? Did they fail? How long did they take? Mission Control gives you the full picture after the fact, but there is no live feed. The other option is refreshing a dashboard or tailing logs. I wanted something quieter.

So a few weeks ago I tweeted exactly that:

“Solid Queue is my default for background jobs in Rails. Still feels a bit blind without real-time visibility though…”

I decided to fix it the Telesink way: feed job lifecycle events straight into the live feed.

A couple of days later I shared this quick demo:

Watch the first live job monitoring dashboard in action

The response was good enough that I cleaned it up and extracted the code into the official Telesink ActiveJob integration.

The gem telesink-activejob gives every Rails app automatic real-time visibility into its background jobs. It pairs nicely with Mission Control instead of replacing it.

Installation

Add this to your Gemfile: 

gem "telesink-activejob"

Then run:

bundle install

Configuration

No extra setup required. It reuses the same TELESINK_ENDPOINT you already have from the core Telesink Ruby SDK.

(Optional but recommended) Want job events in their own clean dashboard/feed? Set a dedicated sink: 

export TELESINK_ACTIVEJOB_ENDPOINT=https://app.telesink.com/api/v1/sinks/your_jobs_sink_token/events

For self-hosted Telesink, just point it at your own server.

Usage

That’s it. Every job that inherits from ApplicationJob (or directly from ActiveJob::Base) now automatically sends four events:

job.enqueued
when the job is queued (includes queue name)
job.started
when execution begins (includes queue name)
job.succeeded
when it finishes successfully (includes duration in seconds)
job.failed
when it fails (includes the exception class and message)

No include statements, no manual calls, no callbacks to remember. It just works with Solid Queue, Sidekiq, GoodJob, or any other ActiveJob backend.

If you prefer explicit control, you can opt in manually: 

class MyJob < ApplicationJob
  include Telesink::ActiveJob::Telesinkable
  # ...
end

See it live in the demo dashboard (the same one I showed in the tweet).

What’s under the hood

The gem is tiny and uses only standard Rails ActiveJob hooks. It:

  • automatically instruments every job without touching your existing code
  • adds useful context (queue, duration, error details)
  • respects the same idempotency and SDK tagging rules as the core Ruby gem
  • gracefully does nothing if Telesink is disabled

It is small on purpose, just like the rest of Telesink.

Next steps

This is the first official integration built on top of Telesink. I will keep shipping more tools for Rails and beyond. Let me know on X what you want to see next.

Official Telesink tools:

The complete source is at github.com/telesink/telesink-activejob. It is MIT licensed.

Now go add the gem and watch your background jobs appear in your Telesink feed.

Follow along on X at @kyrylo.