hawk-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ad454243c7e4906716bba745c89009b7e4a0925fb00e7c7c246ce4abc7ee421
+  data.tar.gz: 8606ee7347422ec4f09f9f22815226da8668799350fae28f3a5bebcf3cff4875
+SHA512:
+  metadata.gz: d6e47dc81d3f81dfb543c1a69ef2bb5ba706c4c913904cdb3e81b425c9278ee27c51d58cd77495066b429f3f6a94c1ffc7448c6e54865a0cba6a00920f2705b8
+  data.tar.gz: d8594608dee49b994127308f54695780acb67348c0dcad34f8c274e6d942c9483b67e3ccd9018f01e74146866de608cb879f62a818a2315e538a45fd0e225604

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## [0.1.0] - 2026-04-03
+
+### Added
+
+- Initial release of hawk-rails gem
+- Automatic exception catching via Rack middleware
+- Manual event sending via `Hawk::Rails.send`
+- Backtrace parsing with source code context
+- Request info capture (URL, method, headers, params, IP)
+- User auto-detection via Warden/Devise
+- Anonymous user ID generation for affected users tracking
+- Global and per-event context support
+- `before_send` hook for event filtering and sensitive data removal
+- Error level detection (fatal/error)
+- Rails and Ruby addons (version, environment, platform)
+- Async event delivery (configurable)
+- Custom collector endpoint support
+- Rails generator for initializer setup (`rails g hawk_rails:install:install`)
+- Configurable source code context lines
+- Environment-based activation (default: production, staging)

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rspec", "~> 3.0"
+gem "webmock", "~> 3.0"
+gem "rake", "~> 13.0"
+gem "rubocop", "~> 1.0"
+gem "railties", ">= 8.0"
+gem "actionpack", ">= 8.0"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hawk Team
+
+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,210 @@
+# Hawk Rails
+
+Ruby on Rails catcher for [Hawk](https://hawk.so) error tracker. Captures unhandled exceptions and custom events in Rails 8+ applications and sends them to Hawk.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "hawk-rails"
+```
+
+Run:
+
+```bash
+bundle install
+```
+
+Generate the initializer:
+
+```bash
+rails generate hawk_rails:install:install
+```
+
+This creates `config/initializers/hawk.rb` with all available options.
+
+## Configuration
+
+Set your integration token (get it at [hawk.so](https://hawk.so) → Project Settings → Integrations):
+
+```ruby
+# config/initializers/hawk.rb
+Hawk::Rails.configure do |config|
+  config.token = ENV.fetch("HAWK_TOKEN")
+end
+```
+
+### All Options
+
+```ruby
+Hawk::Rails.configure do |config|
+  # Required: integration token
+  config.token = ENV.fetch("HAWK_TOKEN")
+
+  # Application release/version (for source maps & suspected commits)
+  config.release = ENV.fetch("APP_VERSION", nil)
+
+  # Global context attached to every event
+  config.context = { app_name: "MyApp", server: Socket.gethostname }
+
+  # Default user (overridden by per-event user or Warden/Devise auto-detection)
+  config.user = { id: "system", name: "Background Worker" }
+
+  # Environments where Hawk is active (default: production, staging)
+  config.enabled_environments = %w[production staging]
+
+  # Source code lines to include around each backtrace frame (default: 5)
+  config.source_code_lines = 5
+
+  # Send events asynchronously (default: true)
+  config.async = true
+
+  # Custom collector endpoint (overrides auto-detected URL from token)
+  config.collector_endpoint = "https://custom-collector.example.com/"
+
+  # Filter or modify events before sending (return false to drop)
+  config.before_send = ->(event) {
+    # Remove sensitive params
+    if event.dig(:payload, :context, :request, :params)
+      event[:payload][:context][:request][:params].delete(:password)
+      event[:payload][:context][:request][:params].delete(:credit_card)
+    end
+    event
+  }
+end
+```
+
+## Usage
+
+### Automatic Error Catching
+
+Hawk Rails automatically catches all unhandled exceptions via Rack middleware. No extra code needed — just configure your token and deploy.
+
+### Manual Event Sending
+
+```ruby
+begin
+  risky_operation
+rescue => e
+  Hawk::Rails.send(e)
+end
+```
+
+With context:
+
+```ruby
+Hawk::Rails.send(error, context: { order_id: order.id, step: "payment" })
+```
+
+With user info:
+
+```ruby
+Hawk::Rails.send(error, user: { id: current_user.id.to_s, name: current_user.name })
+```
+
+### User Detection
+
+Hawk Rails automatically detects the current user via Warden/Devise when available. If no user is found, an anonymous user ID is generated for Affected Users tracking.
+
+You can also set a global default user:
+
+```ruby
+Hawk::Rails.configure do |config|
+  config.user = { id: "worker-1", name: "Sidekiq Worker" }
+end
+```
+
+### Sensitive Data Filtering
+
+Use `before_send` to strip sensitive data before it leaves your server:
+
+```ruby
+Hawk::Rails.configure do |config|
+  config.before_send = ->(event) {
+    # Drop all events from a specific error class
+    return false if event[:payload][:type] == "ActionController::RoutingError"
+
+    # Remove auth headers
+    headers = event.dig(:payload, :context, :request, :headers)
+    headers&.delete("Authorization")
+
+    event
+  }
+end
+```
+
+### Event Format
+
+Each event sent to Hawk follows the [Hawk Event Format](https://docs.hawk.so/event-format):
+
+```json
+{
+  "token": "your-integration-token",
+  "catcherType": "errors/ruby",
+  "payload": {
+    "title": "undefined method `name' for nil:NilClass",
+    "type": "NoMethodError",
+    "backtrace": [
+      {
+        "file": "/app/models/user.rb",
+        "line": 42,
+        "column": 0,
+        "function": "full_name",
+        "sourceCode": [
+          { "line": 40, "content": "  def full_name" },
+          { "line": 41, "content": "    first = profile.first_name" },
+          { "line": 42, "content": "    last = profile.name" }
+        ]
+      }
+    ],
+    "level": 2,
+    "release": "v2.1.0",
+    "catcherVersion": "0.1.0",
+    "context": {
+      "request": {
+        "url": "https://example.com/users/42",
+        "method": "GET",
+        "ip": "203.0.113.1"
+      }
+    },
+    "user": { "id": "42", "name": "John Doe" },
+    "addons": {
+      "rails": { "version": "8.0.0", "environment": "production" },
+      "ruby": { "version": "3.3.0", "platform": "x86_64-linux", "engine": "ruby" }
+    }
+  }
+}
+```
+
+### Addons
+
+Hawk Rails automatically collects:
+
+- **Rails**: version, environment
+- **Ruby**: version, platform, engine
+
+### Error Levels
+
+Error levels are automatically determined:
+
+| Level   | Value | Errors                                           |
+|---------|-------|--------------------------------------------------|
+| Fatal   | 1     | `SystemExit`, `SignalException`, `NoMemoryError`  |
+| Error   | 2     | `RuntimeError`, `StandardError`, and subclasses    |
+
+## Requirements
+
+- Ruby >= 3.2
+- Rails >= 8.0
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/hawk-rails.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/hawk/rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hawk-rails"
+  spec.version       = Hawk::Rails::VERSION
+  spec.authors       = ["Alexander Panasenkov"]
+  spec.email         = ["apanasenkov@capaa.ru"]
+
+  spec.summary       = "Hawk error tracker catcher for Ruby on Rails"
+  spec.description   = "Captures unhandled exceptions and custom events in Rails 8+ applications and sends them to Hawk (hawk.so) error tracker."
+  spec.homepage      = "https://github.com/capaas/hawk-rails"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata["homepage_uri"]    = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"]   = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?("spec/", ".git", ".github", "bin/")
+    end
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "railties", "~> 8.0"
+  spec.add_dependency "net-http", "~> 0.4"
+
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "actionpack", "~> 8.0"
+end

data/lib/generators/hawk_rails/install/install_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module HawkRails
+  module Install
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a Hawk Rails initializer file"
+
+      def create_initializer
+        template "hawk.rb.tt", "config/initializers/hawk.rb"
+      end
+
+      def show_instructions
+        say ""
+        say "Hawk Rails has been installed!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Set your integration token in config/initializers/hawk.rb"
+        say "     or via the HAWK_TOKEN environment variable."
+        say "  2. Restart your Rails server."
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/hawk_rails/install/templates/hawk.rb.tt

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+Hawk::Rails.configure do |config|
+  # Your Hawk integration token (required).
+  # Get it at https://hawk.so in Project Settings > Integrations.
+  config.token = ENV.fetch("HAWK_TOKEN", nil)
+
+  # Application release/version identifier.
+  # Used for source maps and suspected commits tracking.
+  # config.release = ENV.fetch("APP_VERSION", nil)
+
+  # Global context — free-format hash attached to every event.
+  # config.context = { app_name: "MyApp" }
+
+  # Environments where Hawk is active (default: production, staging).
+  config.enabled_environments = %w[production staging]
+
+  # Number of source code lines to include around each backtrace frame (default: 5).
+  # config.source_code_lines = 5
+
+  # Send events asynchronously in a background thread (default: true).
+  # config.async = true
+
+  # Custom collector endpoint (override auto-detected URL).
+  # config.collector_endpoint = "https://your-custom-collector.example.com/"
+
+  # Hook to filter or modify events before sending.
+  # Return the modified event, or false to drop it entirely.
+  # config.before_send = ->(event) {
+  #   if event.dig(:payload, :context, :request, :params)
+  #     event[:payload][:context][:request][:params].delete(:password)
+  #   end
+  #   event
+  # }
+end

data/lib/hawk/rails/backtrace_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    class BacktraceParser
+      BACKTRACE_LINE_REGEX = /\A(.+):(\d+)(?::in\s+[`'](.+)')?\z/
+
+      def initialize(backtrace, source_lines: 5)
+        @backtrace = backtrace || []
+        @source_lines = source_lines
+      end
+
+      def parse
+        @backtrace.map { |line| parse_line(line) }.compact
+      end
+
+      private
+
+      def parse_line(line)
+        match = BACKTRACE_LINE_REGEX.match(line)
+        return nil unless match
+
+        file = match[1]
+        line_number = match[2].to_i
+        function = match[3]
+
+        entry = {
+          file: file,
+          line: line_number,
+          column: 0,
+          function: function
+        }
+
+        source_code = SourceCodeReader.read(file, line_number, @source_lines)
+        entry[:sourceCode] = source_code if source_code
+
+        entry
+      end
+    end
+  end
+end

data/lib/hawk/rails/catcher.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Hawk
+  module Rails
+    class Catcher
+      include Singleton
+
+      def send_event(error, context: nil, user: nil, request_info: nil)
+        return unless enabled?
+
+        event = Event.new(error, context: context, user: user, request_info: request_info)
+        payload = event.to_payload
+
+        if (hook = Hawk::Rails.configuration.before_send)
+          payload = hook.call(payload)
+          return if payload == false
+        end
+
+        deliver(payload)
+      rescue => e
+        warn "[Hawk] Failed to process event: #{e.message}"
+      end
+
+      def self.reset!
+        @singleton__instance__ = nil
+        @singleton__mutex__ = Mutex.new
+      end
+
+      private
+
+      def enabled?
+        config = Hawk::Rails.configuration
+        return false unless config.valid?
+
+        if defined?(::Rails)
+          config.enabled_environments.include?(::Rails.env.to_s)
+        else
+          true
+        end
+      end
+
+      def deliver(payload)
+        if Hawk::Rails.configuration.async
+          Thread.new { post(payload) }
+        else
+          post(payload)
+        end
+      end
+
+      def post(payload)
+        endpoint = Hawk::Rails.configuration.resolved_endpoint
+        uri = URI.parse(endpoint)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = Net::HTTP::Post.new(uri.path.empty? ? "/" : uri.path)
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+        request.body = JSON.generate(payload)
+
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          warn "[Hawk] Failed to send event: HTTP #{response.code}"
+        end
+      rescue => e
+        warn "[Hawk] Network error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/hawk/rails/configuration.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    class Configuration
+      LEVELS = {
+        fatal: 1,
+        error: 2,
+        warning: 4,
+        info: 8,
+        debug: 16
+      }.freeze
+
+      attr_accessor :token,
+                    :release,
+                    :context,
+                    :user,
+                    :before_send,
+                    :collector_endpoint,
+                    :source_code_lines,
+                    :enabled_environments,
+                    :async
+
+      def initialize
+        @token = nil
+        @release = nil
+        @context = {}
+        @user = nil
+        @before_send = nil
+        @collector_endpoint = nil
+        @source_code_lines = 5
+        @enabled_environments = %w[production staging]
+        @async = true
+      end
+
+      def integration_id
+        return nil unless @token
+
+        decoded = JSON.parse(Base64.decode64(@token))
+        decoded["integrationId"]
+      rescue JSON::ParserError, ArgumentError
+        nil
+      end
+
+      def resolved_endpoint
+        @collector_endpoint || begin
+          id = integration_id
+          raise ConfigurationError, "Invalid integration token" unless id
+
+          "https://#{id}.k1.hawk.so/"
+        end
+      end
+
+      def valid?
+        !@token.nil? && !@token.empty? && !integration_id.nil?
+      end
+    end
+
+    class ConfigurationError < StandardError; end
+  end
+end

data/lib/hawk/rails/event.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    class Event
+      attr_reader :error, :context, :user, :request_info
+
+      def initialize(error, context: nil, user: nil, request_info: nil)
+        @error = error
+        @context = context
+        @user = user
+        @request_info = request_info
+      end
+
+      def to_payload
+        config = Hawk::Rails.configuration
+
+        {
+          token: config.token,
+          catcherType: CATCHER_TYPE,
+          payload: build_payload(config)
+        }
+      end
+
+      private
+
+      def build_payload(config)
+        payload = {
+          title: error.message,
+          type: error.class.name,
+          backtrace: parse_backtrace(config),
+          release: config.release,
+          catcherVersion: VERSION,
+          context: merged_context(config),
+          user: resolved_user(config),
+          addons: build_addons
+        }
+
+        payload[:level] = determine_level
+        payload.compact
+      end
+
+      def parse_backtrace(config)
+        BacktraceParser.new(
+          error.backtrace,
+          source_lines: config.source_code_lines
+        ).parse
+      end
+
+      def merged_context(config)
+        result = {}
+        result.merge!(config.context) if config.context.is_a?(Hash)
+        result.merge!(@context) if @context.is_a?(Hash)
+        result.merge!(request_context) if @request_info
+        result.empty? ? nil : result
+      end
+
+      def request_context
+        return {} unless @request_info
+
+        {
+          request: {
+            url: @request_info[:url],
+            method: @request_info[:method],
+            headers: @request_info[:headers],
+            params: @request_info[:params],
+            ip: @request_info[:ip]
+          }.compact
+        }
+      end
+
+      def resolved_user(config)
+        return @user if @user
+        return config.user if config.user
+
+        { id: generate_anonymous_id }
+      end
+
+      def generate_anonymous_id
+        require "digest"
+        Digest::SHA256.hexdigest("hawk-anonymous-#{Socket.gethostname}")[0..15]
+      end
+
+      def build_addons
+        {
+          rails: {
+            version: ::Rails::VERSION::STRING,
+            environment: ::Rails.env
+          },
+          ruby: {
+            version: RUBY_VERSION,
+            platform: RUBY_PLATFORM,
+            engine: RUBY_ENGINE
+          }
+        }
+      rescue NameError
+        {
+          ruby: {
+            version: RUBY_VERSION,
+            platform: RUBY_PLATFORM,
+            engine: RUBY_ENGINE
+          }
+        }
+      end
+
+      def determine_level
+        case error
+        when SystemExit, SignalException, NoMemoryError, SystemStackError
+          Configuration::LEVELS[:fatal]
+        when ScriptError, SecurityError
+          Configuration::LEVELS[:error]
+        when RuntimeError, StandardError
+          Configuration::LEVELS[:error]
+        else
+          Configuration::LEVELS[:error]
+        end
+      end
+    end
+  end
+end

data/lib/hawk/rails/middleware.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Exception => e
+        request = ActionDispatch::Request.new(env) if defined?(ActionDispatch::Request)
+
+        request_info = if request
+          {
+            url: request.url,
+            method: request.request_method,
+            headers: extract_headers(env),
+            params: safe_params(request),
+            ip: request.remote_ip
+          }
+        end
+
+        user = extract_user(env)
+
+        Catcher.instance.send_event(e, request_info: request_info, user: user)
+
+        raise
+      end
+
+      private
+
+      def extract_headers(env)
+        env.each_with_object({}) do |(key, value), headers|
+          next unless key.start_with?("HTTP_")
+          next if key == "HTTP_COOKIE"
+
+          header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
+          headers[header_name] = value
+        end
+      end
+
+      def safe_params(request)
+        request.filtered_parameters
+      rescue
+        {}
+      end
+
+      def extract_user(env)
+        return nil unless defined?(::Warden) || env["warden"]
+
+        warden = env["warden"]
+        return nil unless warden
+
+        current_user = warden.user
+        return nil unless current_user
+
+        {
+          id: current_user.try(:id)&.to_s,
+          name: current_user.try(:name) || current_user.try(:email),
+          url: nil
+        }.compact
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/hawk/rails/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "hawk_rails.configure" do |app|
+        app.middleware.insert_before(0, Hawk::Rails::Middleware)
+      end
+
+      config.after_initialize do
+        if Hawk::Rails.configuration.valid?
+          ::Rails.logger&.info("[Hawk] Catcher initialized for #{::Rails.env}")
+        else
+          ::Rails.logger&.warn("[Hawk] Integration token is not configured. Set it in config/initializers/hawk.rb")
+        end
+      end
+    end
+  end
+end

data/lib/hawk/rails/source_code_reader.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    class SourceCodeReader
+      class << self
+        def read(file, line_number, context_lines = 5)
+          return nil unless file && File.exist?(file) && File.readable?(file)
+
+          lines = File.readlines(file)
+          start_line = [line_number - context_lines, 1].max
+          end_line = [line_number + context_lines, lines.size].min
+
+          (start_line..end_line).map do |n|
+            {
+              line: n,
+              content: lines[n - 1]&.chomp || ""
+            }
+          end
+        rescue Errno::ENOENT, Errno::EACCES
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/hawk/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Hawk
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/hawk/rails.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+require "base64"
+require "net/http"
+require "uri"
+
+require_relative "rails/version"
+require_relative "rails/configuration"
+require_relative "rails/event"
+require_relative "rails/backtrace_parser"
+require_relative "rails/source_code_reader"
+require_relative "rails/catcher"
+require_relative "rails/middleware"
+require_relative "rails/railtie"
+
+module Hawk
+  module Rails
+    CATCHER_TYPE = "errors/ruby"
+
+    class << self
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def send(error, context: nil, user: nil)
+        Catcher.instance.send_event(error, context: context, user: user)
+      end
+
+      def reset!
+        @configuration = Configuration.new
+        Catcher.reset!
+      end
+    end
+  end
+end

data/lib/hawk-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "hawk/rails"

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: hawk-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Panasenkov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: Captures unhandled exceptions and custom events in Rails 8+ applications
+  and sends them to Hawk (hawk.so) error tracker.
+email:
+- apanasenkov@capaa.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hawk-rails.gemspec
+- lib/generators/hawk_rails/install/install_generator.rb
+- lib/generators/hawk_rails/install/templates/hawk.rb.tt
+- lib/hawk-rails.rb
+- lib/hawk/rails.rb
+- lib/hawk/rails/backtrace_parser.rb
+- lib/hawk/rails/catcher.rb
+- lib/hawk/rails/configuration.rb
+- lib/hawk/rails/event.rb
+- lib/hawk/rails/middleware.rb
+- lib/hawk/rails/railtie.rb
+- lib/hawk/rails/source_code_reader.rb
+- lib/hawk/rails/version.rb
+homepage: https://github.com/capaas/hawk-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/capaas/hawk-rails
+  source_code_uri: https://github.com/capaas/hawk-rails
+  changelog_uri: https://github.com/capaas/hawk-rails/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Hawk error tracker catcher for Ruby on Rails
+test_files: []