sentry-good_job 6.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd17c2d28618ace1fe96fd34f6f39035c7a72db021555dcbd7239a727603f340
+  data.tar.gz: 784f07f7a32ec531bb35327f55b17ebe303b25095af640f8016373547810719f
+SHA512:
+  metadata.gz: 2ef631f7d3df7cc2de495e64ecb325980ae95b3809f208fcabcbf276529b3c3c1e0fe04660d6f7aae08b898df6d7fc73f40176e8b381ccf690cfa5868a61d289
+  data.tar.gz: c349ca2697b3435f30469d0ee21c730fec186931017eb94400bff9fa2795331a2845ed66eae82142fa7e7953b5920fc4b116d732fd531f0f23bc740038dcaf93

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## 6.2.0
+
+### Features
+
+- Initial release of sentry-good_job integration
+- Automatic error capture for ActiveJob workers using Good Job
+- Performance monitoring for job execution
+- Automatic cron monitoring setup for scheduled jobs
+- Context preservation and trace propagation
+- Configurable error reporting options
+- Rails integration with automatic setup
+
+### Configuration Options
+
+#### Good Job Specific Options
+- `enable_cron_monitors`: Enable cron monitoring for scheduled jobs
+
+#### ActiveJob Options (handled by sentry-rails)
+- `config.rails.active_job_report_on_retry_error`: Only report errors after all retry attempts are exhausted
+- `config.send_default_pii`: Include job arguments in error context
+
+**Note**: The Good Job integration now leverages sentry-rails for core ActiveJob functionality, including trace propagation, user context preservation, and error reporting.
+
+### Integration Features
+
+- Seamless integration with Rails applications
+- Automatic setup when Good Job integration is enabled
+- Support for both manual and automatic cron monitoring
+- Respects ActiveJob retry configuration
+- Comprehensive error context and performance metrics

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,37 @@
+# Code of Conduct
+
+## Our Pledge
+
+We pledge to make participation in our community a harassment-free experience for everyone. We operate on principles of mutual respect, privacy, and authentic engagement. We value substantive contributions and clarity on intentions.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment include:
+
+* **Authenticity:** Engaging with genuine curiosity and admitting uncertainty rather than feigning knowledge.
+
+* **Responsible Innovation:** Taking full responsibility for any content or code contributed, whether manually written or generated by automation tools.
+
+* **Gentle Correction:** Responding politely to errors. We view mistakes as opportunities for learning, provided they are addressed with humility.
+
+* **Inclusive Language:** Using language that welcomes diverse perspectives and respects the privacy and identity of all participants.
+
+Examples of unacceptable behavior include:
+
+* **Harassment:** Public or private harassment, trolling, or insulting comments.
+
+* **Weaponized Complexity:** Using jargon or overwhelming volume (including automated spam) to silence others.
+
+* **Publishing Private Information:** Sharing others' data or personal context without explicit permission.
+
+## Artificial Intelligence & Automation
+
+In accordance with our commitment to **Collective Awareness**:
+
+* Contributors are responsible for the accuracy and security of any AI-generated artifacts they submit.
+
+* "The AI wrote it" is not a valid excuse for introducing bugs, security vulnerabilities, or bias.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@kiskolabs.com. All complaints will be reviewed and investigated promptly and fairly.

data/CONTRIBUTING.md

@@ -0,0 +1,35 @@
+# Contributing Guidelines
+
+Thank you for your interest in contributing. We value **learning over perfection** but require **rigor and responsibility**.
+
+## The Golden Rule of Automation
+
+We welcome the use of AI and automation tools to reduce toil, but you must strictly adhere to the following:
+
+1.  **You are the Author:** You act as the responsible agent for any code you submit. You must review, debug, and understand every line.
+
+2.  **Manage Cognitive Load:** Do not submit massive, unreviewed automated dumps. Respect the reviewers' time by annotating complex logic.
+
+3.  **Security:** Never feed project secrets or private context into public AI models.
+
+## How to Contribute
+
+### 1. Reporting Issues
+
+* **Verify Accuracy:** Before posting, verify your information. Avoid generalizations.
+
+* **Use Structured Inputs:** Use our Issue Templates to provide clear goals, constraints, and reproduction steps. This helps us understand the context immediately.
+
+### 2. Pull Request Process
+
+* **Scope:** Keep PRs focused on a single goal.
+
+* **Context:** Explain *why* the change is necessary. Transparency builds trust.
+
+* **Testing:** Run all smoke tests and regression checks locally. We prioritize "Safety First."
+
+### 3. Review Process
+
+* We encourage **productive friction**. Expect questions about your approach.
+
+* If a reviewer suggests a change, view it as **mutual aid**, not criticism.

data/GOVERNANCE.md

@@ -0,0 +1,31 @@
+# Project Governance
+
+## Overview
+
+This project balances **individual autonomy** with **collective coordination**. We aim for a workflow that supports rapid iteration while maintaining strict guardrails for safety and architectural integrity.
+
+## Roles
+
+### Contributors
+
+Anyone who submits code, documentation, or participates in discussions. Contributors are expected to exercise **Direct Action**—taking ownership of problems they identify—while adhering to our quality standards.
+
+### Maintainers (Human Oversight)
+
+Maintainers are responsible for:
+
+1.  **Strategic Judgment:** Defining scope and architectural direction.
+
+2.  **Review:** verifying that contributions (human or automated) meet security and logic standards.
+
+3.  **Consensus Building:** Facilitating decisions when the community is divided.
+
+## Decision Making process
+
+### Lazy Consensus
+
+For most routine changes, we operate on "lazy consensus." If a proposal is made and no objections are raised within two weeks, it is considered approved.
+
+### Strategic Alignment
+
+Major architectural changes, high-risk automation integrations, or changes that affect business logic require explicit approval from the Maintainers. We prioritize **substance over performance**—a change must solve a real problem, not just appear polished.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andrei Makarov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,203 @@
+<p align="center">
+  <a href="https://sentry.io" target="_blank" align="center">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-logo-black.png" width="280">
+  </a>
+  <br>
+</p>
+
+# sentry-good_job, the Good Job integration for Sentry's Ruby client
+
+---
+
+[![Gem Version](https://img.shields.io/gem/v/sentry-good_job.svg)](https://rubygems.org/gems/sentry-good_job)
+![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/sentry_good_job_test.yml/badge.svg)
+[![Coverage Status](https://img.shields.io/codecov/c/github/getsentry/sentry-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/sentry-ruby/branch/master)
+[![Gem](https://img.shields.io/gem/dt/sentry-good_job.svg)](https://rubygems.org/gems/sentry-good_job/)
+[![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-good_job&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-good_job&package-manager=bundler&version-scheme=semver)
+
+[Documentation](https://docs.sentry.io/platforms/ruby/guides/good_job/) | [Bug Tracker](https://github.com/getsentry/sentry-ruby/issues) | [Forum](https://forum.sentry.io/) | IRC: irc.freenode.net, #sentry
+
+The official Ruby-language client and integration layer for the [Sentry](https://github.com/getsentry/sentry) error reporting API.
+
+## Getting Started
+
+### Install
+
+```ruby
+gem "sentry-ruby"
+gem "sentry-rails"
+gem "good_job"
+gem "sentry-good_job"
+```
+
+Then you're all set! `sentry-good_job` will automatically capture exceptions from your ActiveJob workers when using Good Job as the backend!
+
+## Features
+
+- **Automatic Error Capture**: Captures exceptions from ActiveJob workers using Good Job
+- **Performance Monitoring**: Tracks job execution times and performance metrics
+- **Cron Monitoring**: Automatic setup for scheduled jobs with cron monitoring
+- **Context Preservation**: Maintains user context and trace propagation across job executions
+- **Configurable Reporting**: Control when errors are reported (after retries, only dead jobs, etc.)
+- **Rails Integration**: Seamless integration with Rails applications
+
+## Configuration
+
+The integration can be configured through Sentry's configuration:
+
+```ruby
+Sentry.init do |config|
+  config.dsn = 'your-dsn-here'
+  
+  # Good Job specific configuration
+  config.good_job.enable_cron_monitors = true
+  
+  # ActiveJob configuration (handled by sentry-rails)
+  config.rails.active_job_report_on_retry_error = false
+  config.send_default_pii = false
+
+  # Optional: Configure logging for debugging
+  config.sdk_logger = Rails.logger
+end
+```
+
+### Configuration Options
+
+#### Good Job Specific Options
+
+- `enable_cron_monitors` (default: `true`): Enable cron monitoring for scheduled jobs
+
+#### ActiveJob Options (handled by sentry-rails)
+
+- `config.rails.active_job_report_on_retry_error` (default: `false`): Only report errors after all retry attempts are exhausted
+- `config.send_default_pii` (default: `false`): Include job arguments in error context (be careful with sensitive data)
+- `config.sdk_logger` (default: `nil`): Configure the SDK logger for custom logging needs (general Sentry configuration)
+
+**Note**: The Good Job integration now leverages sentry-rails for core ActiveJob functionality, including trace propagation, user context preservation, and error reporting. This provides better integration and reduces duplication.
+
+## Usage
+
+### Automatic Setup
+
+The integration works automatically once installed. It will:
+
+1. **Capture exceptions** from ActiveJob workers using sentry-rails
+2. **Set up performance monitoring** for job execution with enhanced GoodJob-specific metrics
+3. **Automatically configure cron monitoring** for scheduled jobs
+4. **Preserve user context and trace propagation** across job executions
+5. **Add GoodJob-specific context** including queue name, executions, priority, and latency
+
+### Cron Monitoring
+
+For scheduled jobs, cron monitoring is automatically set up based on your Good Job configuration:
+
+```ruby
+# config/application.rb
+config.good_job.cron = {
+  'my_scheduled_job' => {
+    class: 'MyScheduledJob',
+    cron: '0 * * * *' # Every hour
+  }
+}
+```
+
+You can also manually set up cron monitoring:
+
+```ruby
+class MyScheduledJob < ApplicationJob
+  include Sentry::Cron::MonitorCheckIns
+
+  sentry_monitor_check_ins(
+    slug: "my_scheduled_job",
+    monitor_config: Sentry::Cron::MonitorConfig.from_crontab("0 * * * *", timezone: "UTC")
+  )
+end
+```
+
+### Custom Error Handling
+
+The integration respects ActiveJob's retry configuration and will only report errors based on your settings:
+
+```ruby
+class MyJob < ApplicationJob
+  retry_on StandardError, wait: :exponentially_longer, attempts: 3
+  
+  def perform
+    # This will only be reported to Sentry after 3 attempts if active_job_report_on_retry_error is true
+    raise "Something went wrong"
+  end
+end
+```
+
+### Debugging and Detailed Logging
+
+The integration uses the standard Sentry SDK logger (`Sentry.configuration.sdk_logger`) for all logging needs. You can configure this logger to get detailed information about what the integration is doing:
+
+```ruby
+Sentry.init do |config|
+  config.dsn = 'your-dsn-here'
+  
+  # Configure the SDK logger for debugging
+  config.sdk_logger = Logger.new($stdout)
+  config.sdk_logger.level = Logger::DEBUG
+
+  # Or use Rails logger with debug level
+  # config.sdk_logger = Rails.logger
+  # config.sdk_logger.level = Logger::DEBUG
+end
+```
+
+#### Log Levels
+
+The integration logs at different levels:
+- **INFO**: Integration setup, cron monitoring configuration, job monitoring setup
+- **WARN**: Configuration issues, missing job classes, cron parsing errors
+- **DEBUG**: Detailed execution flow (when debug level is enabled)
+
+#### What Gets Logged
+
+When logging is enabled, you'll see information about:
+- Job execution start and completion
+- Error capture and reporting decisions
+- Cron monitoring setup and configuration
+- Performance metrics collection
+- GoodJob-specific context enhancement
+- Integration initialization and setup
+
+## Performance Monitoring
+
+When performance monitoring is enabled, the integration will track:
+
+- Job execution time
+- Queue latency (GoodJob-specific)
+- Retry counts
+- Job context and metadata
+- GoodJob-specific metrics (queue name, executions, priority)
+
+## Error Context
+
+The integration automatically adds relevant context to error reports:
+
+- Job class name
+- Job ID
+- Queue name (GoodJob-specific)
+- Execution count (GoodJob-specific)
+- Priority (GoodJob-specific)
+- Enqueued and scheduled timestamps
+- Job arguments (if enabled via send_default_pii)
+- Latency metrics (GoodJob-specific)
+
+## Compatibility
+
+- Ruby 2.4+
+- Rails 5.2+
+- Good Job 3.0+
+- Sentry Ruby SDK 5.28.0+
+
+## Contributing
+
+We welcome contributions! Please see our [contributing guidelines](https://github.com/getsentry/sentry-ruby/blob/master/CONTRIBUTING.md) for details.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE.txt) file for details.

data/SECURITY.md

@@ -0,0 +1,28 @@
+# SECURITY
+
+## Reporting a Vulnerability
+
+**Do NOT** open a public GitHub issue for security vulnerabilities.
+
+Email security details to: **security@kiskolabs.com**
+
+Include: description, steps to reproduce, potential impact, and suggested fix (if available).
+
+### Response Timeline
+
+- We will acknowledge receipt of your report
+- We will provide an initial assessment
+- We will keep you informed of our progress and resolution timeline
+
+### Disclosure Policy
+
+- We will work with you to understand and resolve the issue
+- We will credit you for the discovery (unless you prefer to remain anonymous)
+- We will publish a security advisory after the vulnerability is patched
+- We will coordinate public disclosure with you
+
+## Automation Security
+
+* **Context Isolation:** It is strictly forbidden to include production credentials, API keys, or Personally Identifiable Information (PII) in prompts sent to third-party LLMs or automation services.
+
+* **Supply Chain:** All automated dependencies must be verified.

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "sentry-good_job"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+end

data/lib/sentry/good_job/active_job_extensions.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+# GoodJob-specific extensions to sentry-rails ActiveJob integration
+# This module enhances sentry-rails ActiveJob with GoodJob-specific functionality:
+# - GoodJob-specific context and tags
+# - GoodJob-specific span data enhancements
+module Sentry
+  module GoodJob
+    module ActiveJobExtensions
+      # Enhance sentry-rails ActiveJob context with GoodJob-specific data
+      def self.enhance_sentry_context(job, base_context)
+        return base_context unless job.respond_to?(:queue_name) && job.respond_to?(:executions)
+
+        # Add GoodJob-specific context to the existing sentry-rails context
+        good_job_context = {
+          queue_name: job.queue_name,
+          executions: job.executions,
+          enqueued_at: job.enqueued_at,
+          priority: job.respond_to?(:priority) ? job.priority : nil
+        }
+
+        # Merge with base context, preserving existing structure
+        base_context.merge(good_job: good_job_context)
+      end
+
+      # Enhance sentry-rails ActiveJob tags with GoodJob-specific data
+      def self.enhance_sentry_tags(job, base_tags)
+        return base_tags unless job.respond_to?(:queue_name) && job.respond_to?(:executions)
+
+        good_job_tags = {
+          queue_name: job.queue_name,
+          executions: job.executions
+        }
+
+        # Add priority if available
+        if job.respond_to?(:priority)
+          good_job_tags[:priority] = job.priority
+        end
+
+        base_tags.merge(good_job_tags)
+      end
+
+      # Set up GoodJob-specific ActiveJob extensions
+      def self.setup
+        return unless defined?(::Rails) && ::Sentry.initialized?
+
+        # Hook into sentry-rails ActiveJob integration
+        if defined?(::Sentry::Rails::ActiveJobExtensions::SentryReporter)
+          enhance_sentry_reporter
+        end
+
+        # Set up GoodJob-specific ActiveJob extensions
+        setup_good_job_extensions
+      end
+
+      def self.enhance_sentry_reporter
+        return if defined?(@reporter_enhanced) && @reporter_enhanced
+
+        # Enhance the sentry_context method in SentryReporter
+        ::Sentry::Rails::ActiveJobExtensions::SentryReporter.class_eval do
+          class << self
+            alias_method :original_sentry_context, :sentry_context
+
+            def sentry_context(job)
+              base_context = original_sentry_context(job)
+              Sentry::GoodJob::ActiveJobExtensions.enhance_sentry_context(job, base_context)
+            end
+          end
+        end
+
+        @reporter_enhanced = true
+      end
+
+      def self.setup_good_job_extensions
+        # Extend ActiveJob::Base with GoodJob-specific functionality
+        ActiveSupport.on_load(:active_job) do
+          # Add GoodJob-specific attributes and methods
+          include GoodJobExtensions
+
+          # Ensure the sentry-rails integration is properly set up
+          # by checking if the ActiveJobExtensions module is already included
+          if defined?(::Sentry::Rails::ActiveJobExtensions) && !ancestors.include?(::Sentry::Rails::ActiveJobExtensions)
+            require "sentry/rails/active_job"
+            prepend ::Sentry::Rails::ActiveJobExtensions
+          end
+        end
+      end
+
+      private_class_method :enhance_sentry_reporter, :setup_good_job_extensions
+
+      # GoodJob-specific extensions for ActiveJob
+      module GoodJobExtensions
+        extend ActiveSupport::Concern
+
+        included do
+          # Set up around_enqueue hook for GoodJob-specific enqueue span
+          around_enqueue do |job, block|
+            next block.call unless ::Sentry.initialized?
+
+            # Create enqueue span with GoodJob-specific data
+            ::Sentry.with_child_span(op: "queue.publish", description: job.class.name) do |span|
+              _sentry_set_span_data(span, job)
+              block.call
+            end
+          end
+
+          # GoodJob-specific context is now handled through the enhanced sentry_context method
+          # The sentry-rails integration handles error capturing through SentryReporter.record
+        end
+
+        private
+
+        # Override _sentry_set_span_data to add GoodJob-specific functionality
+        def _sentry_set_span_data(span, job, retry_count: nil)
+          return unless span
+
+          # Call the base implementation if it exists (from sentry-rails)
+          if respond_to?(:_sentry_set_span_data, true) && method(:_sentry_set_span_data).super_method
+            super
+          else
+            # Fallback: implement base functionality directly
+            span.set_data("messaging.message.id", job.job_id)
+            span.set_data("messaging.destination.name", job.queue_name) if job.respond_to?(:queue_name)
+            span.set_data("messaging.message.retry.count", retry_count) if retry_count
+          end
+
+          # Add GoodJob-specific span data (latency)
+          latency = calculate_job_latency(job)
+          span.set_data("messaging.message.receive.latency", latency) if latency
+        end
+
+        # Calculate job latency in milliseconds (GoodJob-specific)
+        def calculate_job_latency(job)
+          return nil unless job.enqueued_at
+
+          ((Time.now.utc - job.enqueued_at) * 1000).to_i
+        end
+      end
+    end
+  end
+end

data/lib/sentry/good_job/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Configuration
+    attr_reader :good_job
+
+    add_post_initialization_callback do
+      @good_job = Sentry::GoodJob::Configuration.new
+      @excluded_exceptions = @excluded_exceptions.concat(Sentry::GoodJob::IGNORE_DEFAULT)
+    end
+  end
+
+  module GoodJob
+    IGNORE_DEFAULT = [
+      "ActiveJob::DeserializationError",
+      "ActiveJob::SerializationError"
+    ]
+
+    class Configuration
+      # Whether to enable cron monitoring for all scheduled jobs
+      # This is GoodJob-specific functionality for monitoring scheduled tasks
+      attr_accessor :enable_cron_monitors
+
+      def initialize
+        @enable_cron_monitors = true
+      end
+    end
+  end
+end

data/lib/sentry/good_job/context_helpers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Helper methods for adding GoodJob-specific information to Sentry context
+# This works WITH sentry-rails, not against it
+module Sentry
+  module GoodJob
+    module ContextHelpers
+      # Add GoodJob-specific information to the existing Sentry Rails context
+      def self.add_context(job, base_context = {})
+        return base_context unless job.respond_to?(:queue_name) && job.respond_to?(:executions)
+
+        good_job_context = {
+          queue_name: job.queue_name,
+          executions: job.executions,
+          enqueued_at: job.enqueued_at,
+          priority: job.respond_to?(:priority) ? job.priority : nil
+        }
+
+        # Note: Job arguments are handled by sentry-rails via send_default_pii configuration
+        # This is controlled by Sentry.configuration.send_default_pii, not GoodJob-specific config
+
+        # Merge with base context
+        base_context.merge(good_job: good_job_context)
+      end
+
+      # Add GoodJob-specific information to the existing Sentry Rails tags
+      def self.add_tags(job, base_tags = {})
+        return base_tags unless job.respond_to?(:queue_name) && job.respond_to?(:executions)
+
+        good_job_tags = {
+          queue_name: job.queue_name,
+          executions: job.executions
+        }
+
+        # Add priority if available
+        if job.respond_to?(:priority)
+          good_job_tags[:priority] = job.priority
+        end
+
+        base_tags.merge(good_job_tags)
+      end
+    end
+  end
+end

data/lib/sentry/good_job/cron_helpers.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+# Sentry Cron Monitoring for Active Job
+# This module provides comprehensive cron monitoring for Active Job scheduled tasks
+# It works with any Active Job adapter, including GoodJob
+# Following Active Job's extension patterns and Sentry's integration guidelines
+module Sentry
+  module GoodJob
+    module CronHelpers
+      # Utility methods for cron parsing and configuration
+      # These methods handle the conversion between Good Job cron expressions and Sentry monitor configs
+      module Helpers
+        # Parse cron expression and create Sentry monitor config
+        def self.monitor_config_from_cron(cron_expression, timezone: nil)
+          return nil unless cron_expression && !cron_expression.strip.empty?
+
+          # Parse cron expression using fugit (same as Good Job)
+          parsed_cron = Fugit.parse_cron(cron_expression)
+          return nil unless parsed_cron
+
+          # Convert to Sentry monitor config
+          if timezone && !timezone.strip.empty?
+            ::Sentry::Cron::MonitorConfig.from_crontab(cron_expression, timezone: timezone)
+          else
+            ::Sentry::Cron::MonitorConfig.from_crontab(cron_expression)
+          end
+        rescue => e
+          Sentry.configuration.sdk_logger.warn "Failed to parse cron expression '#{cron_expression}': #{e.message}"
+          nil
+        end
+
+        # Generate monitor slug from job name
+        def self.monitor_slug(job_name)
+          job_name.to_s.underscore.gsub(/_job$/, "")
+        end
+
+        # Parse cron expression and extract timezone
+        def self.parse_cron_with_timezone(cron_expression)
+          return [cron_expression, nil] unless cron_expression && !cron_expression.strip.empty?
+
+          parts = cron_expression.strip.split(" ")
+          return [cron_expression, nil] unless parts.length > 5
+
+          # Last part might be timezone
+          timezone = parts.last
+          # Comprehensive timezone validation that handles:
+          # - Standard timezone names (UTC, GMT)
+          # - IANA timezone identifiers (America/New_York, Europe/Stockholm)
+          # - Multi-level IANA timezones (America/Argentina/Buenos_Aires)
+          # - UTC offsets (UTC+2, UTC-5, GMT+1, GMT-8)
+          # - Numeric timezones (GMT-5, UTC+2)
+          if timezone.match?(/^[A-Za-z_]+$/) || # Simple timezone names (UTC, GMT, EST, etc.)
+              timezone.match?(/^[A-Za-z_]+\/[A-Za-z_]+$/) || # Single slash timezones (Europe/Stockholm)
+              timezone.match?(/^[A-Za-z_]+\/[A-Za-z_]+\/[A-Za-z_]+$/) || # Multi-slash timezones (America/Argentina/Buenos_Aires)
+              timezone.match?(/^[A-Za-z_]+[+-]\d+$/) || # UTC/GMT offsets (UTC+2, GMT-5)
+              timezone.match?(/^[A-Za-z_]+\/[A-Za-z_]+[+-]\d+$/) # IANA with offset (Europe/Stockholm+1)
+            cron_without_timezone = cron_expression.gsub(/\s+#{Regexp.escape(timezone)}$/, "")
+            [cron_without_timezone, timezone]
+          else
+            [cron_expression, nil]
+          end
+        end
+      end
+
+      # Main integration class that handles all cron monitoring setup
+      # This class follows Good Job's integration patterns and Sentry's extension guidelines
+      class Integration
+        # Track whether setup has already been performed to prevent duplicates
+        @setup_completed = false
+        @reload_hooked = false
+
+        # Set up monitoring for all scheduled jobs from Good Job configuration
+        def self.setup_monitoring_for_scheduled_jobs
+          return unless ::Sentry.initialized?
+          return unless ::Sentry.configuration.good_job.enable_cron_monitors
+          attach_reload_hook_if_available
+          return if @setup_completed
+
+          return unless defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+          cron_config = ::Rails.application.config.good_job.cron
+          return if cron_config.blank?
+
+          added_jobs = []
+          cron_config.each do |cron_key, job_config|
+            job_name = setup_monitoring_for_job(cron_key, job_config)
+            added_jobs << job_name if job_name
+          end
+
+          @setup_completed = true
+          if added_jobs.any?
+            job_list = added_jobs.join(", ")
+            Sentry.configuration.sdk_logger.info "Sentry cron monitoring setup for #{added_jobs.size} scheduled jobs: #{job_list}"
+          else
+            Sentry.configuration.sdk_logger.info "Sentry cron monitoring setup for #{cron_config.keys.size} scheduled jobs"
+          end
+        end
+
+        # Reset setup state (primarily for testing)
+        def self.reset_setup_state!
+          @setup_completed = false
+        end
+
+        # Set up monitoring for a specific job
+        def self.setup_monitoring_for_job(cron_key, job_config)
+          job_class_name = job_config[:class]
+          cron_expression = job_config[:cron]
+
+          return unless job_class_name && cron_expression
+
+          # Defer job class constantization to avoid boot-time issues
+          # The job class will be constantized when the job is actually executed
+          # This prevents issues during development boot and circular dependencies
+
+          # Store the monitoring configuration for later use
+          # We'll set up the monitoring when the job class is first loaded
+          deferred_setup = lambda do
+            job_class = begin
+              job_class_name.constantize
+            rescue NameError => e
+              Sentry.configuration.sdk_logger.warn "Could not find job class '#{job_class_name}' for Sentry cron monitoring: #{e.message}"
+              return
+            end
+
+            # Include Sentry::Cron::MonitorCheckIns module for cron monitoring
+            # only patch if not explicitly included in job by user
+            unless job_class.ancestors.include?(Sentry::Cron::MonitorCheckIns)
+              job_class.include(Sentry::Cron::MonitorCheckIns)
+            end
+
+            # Parse cron expression and create monitor config
+            cron_without_tz, timezone = Sentry::GoodJob::CronHelpers::Helpers.parse_cron_with_timezone(cron_expression)
+            monitor_config = Sentry::GoodJob::CronHelpers::Helpers.monitor_config_from_cron(cron_without_tz, timezone: timezone)
+
+            if monitor_config
+              # Configure Sentry cron monitoring - use cron_key as slug for consistency
+              monitor_slug = Sentry::GoodJob::CronHelpers::Helpers.monitor_slug(cron_key)
+
+              job_class.sentry_monitor_check_ins(
+                slug: monitor_slug,
+                monitor_config: monitor_config
+              )
+
+              job_class_name
+            else
+              Sentry.configuration.sdk_logger.warn "Could not create monitor config for #{job_class_name} with cron '#{cron_expression}'"
+              nil
+            end
+          end
+
+          # Set up monitoring when the job class is first loaded
+          # This defers constantization until the job is actually needed
+          if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+            ::Rails.application.config.after_initialize do
+              deferred_setup.call
+            end
+          else
+            # Fallback for non-Rails environments
+            deferred_setup.call
+          end
+
+          # Return the job name for logging purposes
+          job_class_name
+        end
+
+        # Manually add cron monitoring to a specific job
+        def self.add_monitoring_to_job(job_class, slug: nil, cron_expression: nil, timezone: nil)
+          return unless ::Sentry.initialized?
+
+          # Include Sentry::Cron::MonitorCheckIns module for cron monitoring
+          # only patch if not explicitly included in job by user
+          unless job_class.ancestors.include?(Sentry::Cron::MonitorCheckIns)
+            job_class.include(Sentry::Cron::MonitorCheckIns)
+          end
+
+          # Create monitor config
+          monitor_config = if cron_expression
+            Sentry::GoodJob::CronHelpers::Helpers.monitor_config_from_cron(cron_expression, timezone: timezone)
+          else
+            # Default to hourly monitoring if no cron expression provided
+            ::Sentry::Cron::MonitorConfig.from_crontab("0 * * * *")
+          end
+
+          if monitor_config
+            monitor_slug = slug || Sentry::GoodJob::CronHelpers::Helpers.monitor_slug(job_class.name)
+
+            job_class.sentry_monitor_check_ins(
+              slug: monitor_slug,
+              monitor_config: monitor_config
+            )
+
+            Sentry.configuration.sdk_logger.info "Added Sentry cron monitoring for #{job_class.name} (#{monitor_slug})"
+          end
+        end
+
+        def self.attach_reload_hook_if_available
+          return if @reload_hooked
+          return unless defined?(::ActiveSupport::Reloader)
+
+          ::ActiveSupport::Reloader.to_prepare do
+            @setup_completed = false
+          end
+
+          @reload_hooked = true
+        rescue NameError
+          # ActiveSupport::Reloader not available in this environment
+        end
+      end
+    end
+  end
+end

data/lib/sentry/good_job/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sentry
+  module GoodJob
+    VERSION = "6.2.0"
+  end
+end

data/lib/sentry/good_job.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# This file is kept for backward compatibility and simply requires the main entry point
+require "sentry-good_job"

data/lib/sentry-good_job.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "good_job"
+require "sentry-ruby"
+require "sentry/integrable"
+require "sentry/good_job/version"
+require "sentry/good_job/configuration"
+require "sentry/good_job/context_helpers"
+require "sentry/good_job/active_job_extensions"
+require "sentry/good_job/cron_helpers"
+
+module Sentry
+  module GoodJob
+    extend Sentry::Integrable
+
+    register_integration name: "good_job", version: Sentry::GoodJob::VERSION
+
+    if defined?(::Rails::Railtie)
+      class Railtie < ::Rails::Railtie
+        config.after_initialize do
+          next unless Sentry.initialized? && defined?(::Sentry::Rails)
+
+          # Automatic setup for Good Job when the integration is enabled
+          if Sentry.configuration.enabled_patches.include?(:good_job)
+            Sentry::GoodJob.setup_good_job_integration
+          end
+        end
+      end
+    end
+
+    def self.setup_good_job_integration
+      # Enhance sentry-rails ActiveJob integration with GoodJob-specific context
+      Sentry::GoodJob::ActiveJobExtensions.setup
+
+      # Set up cron monitoring for all scheduled jobs (automatically configured from Good Job config)
+      if Sentry.configuration.good_job.enable_cron_monitors
+        Sentry::GoodJob::CronHelpers::Integration.setup_monitoring_for_scheduled_jobs
+      end
+
+      Sentry.configuration.sdk_logger.info "Sentry Good Job integration initialized automatically"
+    end
+
+    # Delegate capture_exception so internal components can be tested in isolation
+    def self.capture_exception(exception, **options)
+      ::Sentry.capture_exception(exception, **options)
+    end
+  end
+end

data/sentry-good_job.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "lib/sentry/good_job/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "sentry-good_job"
+  spec.version = Sentry::GoodJob::VERSION
+  spec.authors = ["Sentry Team", "Andrei Makarov"]
+  spec.summary = "GoodJob integration for the Sentry error logger"
+  spec.description = "Adds Sentry instrumentation, context helpers, and cron monitoring support to GoodJob-backed ActiveJob workloads."
+  spec.email = "contact@kiskolabs.com"
+  spec.license = "MIT"
+
+  spec.platform = Gem::Platform::RUBY
+  spec.required_ruby_version = ">= 2.4"
+  spec.extra_rdoc_files = ["README.md", "LICENSE.txt"]
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir[
+      "lib/**/*",
+      "bin/*",
+      "CHANGELOG.md",
+      "README.md",
+      "LICENSE.txt",
+      "CODE_OF_CONDUCT.md",
+      "CONTRIBUTING.md",
+      "GOVERNANCE.md",
+      "SECURITY.md",
+      "sentry-good_job.gemspec"
+    ].select { |path| File.file?(path) }
+  end
+
+  github_root_uri = "https://github.com/amkisko/sentry-good_job"
+  spec.homepage = github_root_uri
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => "#{github_root_uri}/tree/main",
+    "changelog_uri" => "#{github_root_uri}/blob/main/CHANGELOG.md",
+    "bug_tracker_uri" => "#{github_root_uri}/issues",
+    "documentation_uri" => "http://www.rubydoc.info/gems/#{spec.name}/#{spec.version}"
+  }
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sentry-ruby", "~> 6"
+  spec.add_dependency "good_job", "~> 4"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: sentry-good_job
+version: !ruby/object:Gem::Version
+  version: 6.2.0
+platform: ruby
+authors:
+- Sentry Team
+- Andrei Makarov
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sentry-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: good_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Adds Sentry instrumentation, context helpers, and cron monitoring support
+  to GoodJob-backed ActiveJob workloads.
+email: contact@kiskolabs.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- GOVERNANCE.md
+- LICENSE.txt
+- README.md
+- SECURITY.md
+- bin/console
+- bin/setup
+- lib/sentry-good_job.rb
+- lib/sentry/good_job.rb
+- lib/sentry/good_job/active_job_extensions.rb
+- lib/sentry/good_job/configuration.rb
+- lib/sentry/good_job/context_helpers.rb
+- lib/sentry/good_job/cron_helpers.rb
+- lib/sentry/good_job/version.rb
+- sentry-good_job.gemspec
+homepage: https://github.com/amkisko/sentry-good_job
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/amkisko/sentry-good_job
+  source_code_uri: https://github.com/amkisko/sentry-good_job/tree/main
+  changelog_uri: https://github.com/amkisko/sentry-good_job/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/amkisko/sentry-good_job/issues
+  documentation_uri: http://www.rubydoc.info/gems/sentry-good_job/6.2.0
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: GoodJob integration for the Sentry error logger
+test_files: []