Generated banner for Integration Ruby On Rails
Generated logo for Integration Ruby On Rails

Integration Ruby On Rails

PostHogOfficialCreated by PostHog

  • Skill
  • Tool integration
  • Software development
  • MIT
  • No issues found

From the author

PostHog integration for Ruby on Rails applications
— the description by PostHog

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for adding PostHog to a Ruby on Rails project. It covers the installation of the posthog-rails and posthog-ruby gems, configuration of initializers, and best practices for event tracking, user identification, and automated error reporting. The skill emphasizes using environment variables for configuration, leveraging class-level methods for event capture, and maintaining consistency with provided implementation patterns to ensure reliable data collection across both backend and frontend environments.

What it does

  • Configures PostHog initialization for Rails applications.
  • Enables automated tracking of unhandled exceptions and background job failures.
  • Provides patterns for manual event capture and user identification.
  • Integrates feature flag support within Rails controllers.
  • Demonstrates how to correlate backend events with frontend sessions.
  • Offers a step-by-step workflow for planning and implementing event tracking.

When to use it

  • When you need to add product analytics to a Ruby on Rails application.
  • When you want to implement automated server-side error tracking.
  • When you need to associate backend events with authenticated users.
  • When you are setting up feature flags for Rails-based features.

Advantages

  • Follows established Rails conventions for gem configuration.
  • Ensures secure handling of API keys via environment variables.
  • Provides clear separation between backend event tracking and frontend instrumentation.
  • Includes built-in support for ActiveJob and Rails error reporting.

Usage examples

“How do I initialize PostHog in my Rails application?”
The agent will guide you to create an initializer file and configure the PostHog client using environment variables for the API key and host.
“How can I track background job failures in Rails?”
The agent will show you how to enable auto_instrument_active_job in the PostHog configuration to automatically capture job class, queue, and arguments.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/posthog/integration-ruby-on-rails/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip integration-ruby-on-rails.zip -d .agents/skills

Documentation by PostHog

PostHog integration for Ruby on Rails

This skill helps you add PostHog analytics to Ruby on Rails applications.

Workflow

Follow these steps in order to complete the integration:

  1. basic-integration-1.0-begin.md - PostHog Setup - Begin ← Start here

  2. basic-integration-1.1-edit.md - PostHog Setup - Edit

  3. basic-integration-1.2-revise.md - PostHog Setup - Revise

  4. basic-integration-1.3-conclude.md - PostHog Setup - Conclusion

Reference files

  • references/EXAMPLE.md - Ruby on Rails example project code

  • references/ruby-on-rails.md - Ruby on rails - docs

  • references/ruby.md - Ruby - docs

  • references/identify-users.md - Identify users - docs

  • references/basic-integration-1.0-begin.md - PostHog setup - begin

  • references/basic-integration-1.1-edit.md - PostHog setup - edit

  • references/basic-integration-1.2-revise.md - PostHog setup - revise

  • references/basic-integration-1.3-conclude.md - PostHog setup - conclusion

The example project shows the target implementation pattern. Consult the documentation for API details.

Key principles

  • Environment variables: Always use environment variables for PostHog keys. Never hardcode them.

  • Minimal changes: Add PostHog code alongside existing integrations. Don't replace or restructure existing code.

  • Match the example: Your implementation should follow the example project's patterns as closely as possible.

Framework guidelines

  • Use posthog-rails gem alongside posthog-ruby for automatic exception capture and ActiveJob instrumentation

  • Run rails generate posthog:install to create the initializer, or manually create config/initializers/posthog.rb

  • Configure auto_capture_exceptions: true to automatically track unhandled exceptions in controllers

  • Configure report_rescued_exceptions: true to also capture exceptions that Rails rescues (e.g. with rescue_from)

  • Configure auto_instrument_active_job: true to track background job failures with job class, queue, and arguments

  • Use PostHog.capture() and PostHog.identify() class-level methods (NOT instance methods) — the posthog-rails gem manages the client lifecycle via PostHog.init

  • Do NOT manually create PostHog::Client instances in Rails — use PostHog.init in the initializer and PostHog.capture/identify everywhere else

  • capture_exception takes POSITIONAL args: PostHog.capture_exception(exception, distinct_id, additional_properties) — do NOT use keyword args

  • Define posthog_distinct_id on the User model for automatic user association in error reports — posthog-rails auto-detects by trying: posthog_distinct_id, distinct_id, id, pk, uuid (in order)

  • For ActiveJob user association, use the class-level DSL posthog_distinct_id ->(user) { user.email } or pass user_id: in a hash argument

  • Store API key in Rails credentials or environment variables, never hardcode

  • For frontend tracking alongside posthog-rails, add the posthog-js snippet to the layout template — posthog-js handles pageviews, session replay, and client-side errors while posthog-ruby handles backend events, server errors, feature flags, and background jobs

  • posthog-ruby is the Ruby SDK gem name (add gem 'posthog-ruby' to Gemfile) but require it with require 'posthog' (NOT require 'posthog-ruby')

  • Use PostHog::Client.new(api_key: key, host: host) for instance-based initialization in scripts and CLIs

  • In CLIs and scripts: MUST call client.shutdown before exit or all events are lost

  • Use begin/rescue/ensure with shutdown in the ensure block for proper cleanup

  • capture and identify take a single hash argument: client.capture(distinct_id: 'user_123', event: 'my_event', properties: { key: 'value' })

  • capture_exception takes POSITIONAL args (not keyword): client.capture_exception(exception, distinct_id, additional_properties) — do NOT use distinct_id: keyword syntax

Identifying users

Identify users during login and signup events. Refer to the example code and documentation for the correct identify pattern for this framework. If both frontend and backend code exist, pass the client-side session and distinct ID using X-POSTHOG-DISTINCT-ID and X-POSTHOG-SESSION-ID headers to maintain correlation.

Error tracking

Add PostHog error tracking to relevant files, particularly around critical user flows and API boundaries.

Files

references/basic-integration-1.2-revise.md


title: PostHog Setup - Revise description: Review and fix any errors in the PostHog integration implementation

Check the project for errors. Read the package.json file for any type checking or build scripts that may provide input about what to fix. Remember that you can find the source code for any dependency in the node_modules directory. Do not spawn subagents.

Ensure that any components created were actually used.

Once all other tasks are complete, run any linter or prettier-like scripts found in the package.json, but ONLY on the files you have edited or created during this session. Do not run formatting or linting across the entire project's codebase.

Status

Status to report in this phase:

  • Finding and correcting errors

  • Report details of any errors you fix

  • Linting, building and prettying


Upon completion, continue with: basic-integration-1.3-conclude.md

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
PostHog
Publisher
PostHog (Official)
Source
PostHog/skills · skills/posthog/integration/skills/ruby-on-rails · commit a5d30e7
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Also distributed in
PostHog/skills

AutoGineer is not affiliated with or endorsed by PostHog.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download integration-ruby-on-rails.zip