errmine 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14575fe3e975be6308fefa8663defb90c80e552766ac0b1c552feee30c3e7209
-  data.tar.gz: a967ca060190180ff8bb6d76abe237f131aab11b842f8b57c1ce6cef16fd417f
+  metadata.gz: b1a9a7a387a6803ba0b0adad94a879f28532586c6e5ac0bb78f8319a01e94258
+  data.tar.gz: f77ffb7eb12eec128b2f83170781bc443b71c171e91852374ab0b3cabd087e8d
 SHA512:
-  metadata.gz: e057ce4bd6639aa550b148c245bb2224ac126546a4cc287842fcb26d5cbf227fddfed1fc473a5d241bf0405511712be256308234a96cc0504e32149214b2489a
-  data.tar.gz: 6291e7878535a180967c319a05d78379962f6209c4e972f062f8d1d0cdfa36c92be4fada846e8d552d9c983fb301d71833dad3cc52f418b4acf7de020e8f35ea
+  metadata.gz: 5e571d17b1b8f989be5c19c3cd0170e0e33ca5046e4f57aeb2cc544f9e8d58e7f1619cfdf115198b19532d3da0d6a1cf12eb1e8528e323908ce4fe4f5d1966fc
+  data.tar.gz: 31a9fb8289ccafb5d7de40beadf653117d240055bfd2d8ecfff708f4465f9b8655989a7c27c24b05bfae0206202efe15bb81a7d7af0484b613555aea2a8de606

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Errmine changelog
 
+## 0.3.0 (2026-11-10)
+- [Breaking] Require Ruby `>= 4.0.0`. Errmine 0.2.0 and earlier required Ruby `>= 3.3.0`.
+- [Feature] Add the `assigned_to_id` option to `Errmine.create_issue` and `Errmine.notify` (in the context), and the `assigned_to_id` setting (default `nil`) as its default, to assign new issues to a Redmine user. Without either, Errmine sends no assignee and Redmine uses the project's default, as before.
+- [Enhancement] Add Ruby warning category opt-in to test helpers.
+- [Fix] Fix cache cleanup crashing with `NoMethodError` when the cache exceeds 500 entries within one cooldown, which dropped every new error until entries expired.
+- [Fix] Report the next occurrence of an error whose report to Redmine failed (HTTP error, timeout, connection error) after 60 seconds (or the cooldown, if shorter) instead of dropping it for the whole cooldown, and log one warning with the error class and the failure.
+- [Fix] Report errors whose message, backtrace or context has invalid UTF-8 or binary bytes, and `Errmine.create_issue` subjects or descriptions with such bytes, with those bytes replaced, instead of failing to build the Redmine request and never reporting them.
+- [Fix] Replace the values of sensitive query parameters in the URL that `Errmine::Middleware` reports with `[FILTERED]`, instead of sending them to Redmine in clear text. Add the `filter_parameters` option (default: the Rails 7.1 list `passw email secret token _key crypt salt certificate otp ssn cvv cvc`); in Rails, the app's `config.filter_parameters` is added to it.
+
+## 0.2.0 (2025-12-24)
+- [Feature] Add app name to issue title for easy identification when multiple apps report to the same Redmine project.
+- [Feature] Include app_name in checksum calculation so same errors in different apps create separate issues.
+- [Feature] Add `Errmine.create_issue` method for creating custom Redmine issues with arbitrary subject, description, tracker, project, and tags.
+- [Feature] Add tags support via the `tags` option for both exception reporting and custom issues.
+- [Feature] Add `default_tags` configuration option for tags applied to all issues.
+- [Maintenance] Update actions/checkout to v6 in CI.
+
 ## 0.1.1 (2025-12-23)
 - [Fix] Fix file permissions for gem packaging.
 - [Fix] Fix gemspec metadata duplicate URI warning.

data/README.md

@@ -4,15 +4,14 @@
 
 # Errmine
 
-[![Build Status](https://github.com/mensfeld/errmine/workflows/ci/badge.svg)](https://github.com/mensfeld/errmine/actions?query=workflow%3Aci)
 [![Gem Version](https://badge.fury.io/rb/errmine.svg)](http://badge.fury.io/rb/errmine)
 
 Dead simple, zero-dependency exception tracking for Redmine.
 
-Errmine automatically creates and updates Redmine issues from Ruby/Rails exceptions. When an error occurs, it creates a new issue. When the same error occurs again, it increments a counter and adds a journal note instead of creating duplicates.
+Errmine automatically creates and updates Redmine issues from Ruby/Rails exceptions. When an error occurs, it creates a new issue. When the same error occurs again after the cooldown, it increments a counter and adds a journal note instead of creating duplicates.
 
 ```
-[a1b2c3d4][47] NoMethodError: undefined method 'foo' for nil...
+[my-app][a1b2c3d4][47] NoMethodError: undefined method 'foo' for nil...
 ```
 
 ## Why Errmine?
@@ -27,24 +26,26 @@ If you already use Redmine for project management, Errmine lets you track produc
 **vs. Exception Notification gem**
 - Automatic deduplication - same error updates existing issue instead of creating duplicates
 - Rate limiting prevents inbox/Redmine flooding during error storms
-- Occurrence counting shows error frequency at a glance
+- Occurrence counter in the subject - counts the reports that passed the cooldown, not every occurrence (at most one per error per cooldown period in each process)
 
 **vs. Rolling your own**
 - Zero dependencies - uses only Ruby stdlib
-- Handles edge cases: rate limiting, timeouts, thread safety, fail-safe error handling
+- Handles edge cases: rate limiting, timeouts, thread safety, fail-safe error handling (reporting is synchronous, see [Synchronous Reporting](#synchronous-reporting))
 - Works out of the box with Rails 7+ Error Reporting API
 
 ## Features
 
 - **Zero dependencies** - Uses only Ruby stdlib (net/http, json, digest, uri)
-- **Automatic deduplication** - Same errors update existing issues instead of creating duplicates
+- **Automatic deduplication** - Same errors update existing issues instead of creating duplicates (no lock across processes, see [Deduplication](#deduplication))
 - **Rate limiting** - Prevents flooding Redmine during error loops
 - **Rails integration** - Works with Rails 7+ Error Reporting API or as Rack middleware
 - **Thread-safe** - Safe to use in multi-threaded environments
-- **Fail-safe** - Never crashes your application, logs errors to stderr
+- **Fail-safe** - Never crashes your application, logs errors to stderr (reporting still blocks the caller, see [Synchronous Reporting](#synchronous-reporting))
 
 ## Installation
 
+Errmine requires Ruby `>= 4.0.0`.
+
 Add to your Gemfile:
 
 ```ruby
@@ -105,8 +106,11 @@ end
 | `project_id` | `ENV['ERRMINE_PROJECT']` or `'bug-tracker'` | Redmine project identifier |
 | `tracker_id` | `1` | Tracker ID (usually 1 = Bug) |
 | `app_name` | `ENV['ERRMINE_APP_NAME']` or `'unknown'` | Application name shown in issues |
-| `enabled` | `true` | Enable/disable notifications |
-| `cooldown` | `300` | Seconds between same-error notifications |
+| `default_tags` | `[]` | Tags (array of strings) added to every issue Errmine creates |
+| `assigned_to_id` | `nil` | Redmine user ID that new issues are assigned to. When `nil`, Errmine sends no assignee and Redmine uses the project's default |
+| `enabled` | `true` | Enable/disable notifications and custom issues |
+| `cooldown` | `300` | Seconds between same-error notifications (after a failed report, the next occurrence is reported after 60 seconds, or after the cooldown if it is shorter) |
+| `filter_parameters` | `%w[passw email secret token _key crypt salt certificate otp ssn cvv cvc]` | Query parameter names whose values the middleware replaces with `[FILTERED]`. Strings and symbols match any part of the name, case-insensitively; regexps match with `match?`. In Rails, the app's `config.filter_parameters` (strings, symbols, regexps; procs are skipped) is added after initialization |
 
 ## Usage
 
@@ -123,10 +127,14 @@ For all Rails versions or any Rack-based application:
 config.middleware.use Errmine::Middleware
 
 # or config.ru (Sinatra, etc.)
+require 'errmine'
+require 'errmine/middleware'
 use Errmine::Middleware
 ```
 
-The middleware captures request context (URL, HTTP method, user via Warden).
+Outside Rails, `require 'errmine'` does not load `Errmine::Middleware`. Require `errmine/middleware` before you use it. In Rails, the Railtie loads it.
+
+The middleware captures request context (URL, HTTP method, user via Warden). The URL includes the query string, with the value of each parameter that matches `filter_parameters` replaced with `[FILTERED]` (for example `/password/edit?reset_password_token=[FILTERED]&page=2`). If a parameter name cannot be decoded, the whole query is replaced: `/path?[FILTERED]`.
 
 ### Manual Notification
 
@@ -137,21 +145,29 @@ begin
   risky_operation
 rescue => e
   Errmine.notify(e, {
-    url: request.url,
+    url: request.filtered_path,
     user: current_user&.email,
+    tags: ['checkout'],
     custom_field: 'any value'
   })
   raise
 end
 ```
 
+- Errmine does not filter a `url` you pass. In Rails, `request.filtered_path` gives the path and query with `config.filter_parameters` applied; `request.url` holds every query value in clear text
+- When set, `url` and `user` add the `**URL:**` and `**User:**` lines to the issue description. Every other key adds one `**Key:** value` line, with the key name capitalized and the value as Ruby text, for example `**Custom_field:** any value`
+- `tags` is optional, an array of strings. When the report creates a new issue, the issue gets `default_tags` plus these tags, without duplicates
+- The issue description also gets a `**Tags:**` line with these tags as a Ruby array, for example `**Tags:** ["checkout"]` (without `default_tags`)
+- When a report that passes the cooldown finds an open issue for the error, it updates that issue and ignores `tags`: Errmine adds no tags to the issue and no tags line to the journal note
+- `assigned_to_id` is optional, a Redmine user ID. When the report creates a new issue, the issue is assigned to this user instead of the configured `assigned_to_id`. It also adds an `**Assigned_to_id:**` line to the description. Updates of an open issue do not change its assignee
+
 ### rescue_from in Controllers
 
 ```ruby
 class ApplicationController < ActionController::Base
   rescue_from StandardError do |e|
     Errmine.notify(e, {
-      url: request.url,
+      url: request.filtered_path,
       user: current_user&.email
     })
     raise e
@@ -159,6 +175,25 @@ class ApplicationController < ActionController::Base
 end
 ```
 
+### Custom Issues
+
+Create a Redmine issue with your own subject and description:
+
+```ruby
+Errmine.create_issue(
+  subject: 'Nightly import failed',
+  description: 'The import stopped at row 1200.',
+  tags: ['import']
+)
+```
+
+- `subject` and `description` are required; the description uses Textile format
+- `project_id`, `tracker_id` and `assigned_to_id` are optional and default to the configured values. Without any `assigned_to_id`, Redmine assigns the project's default assignee
+- `tags` is optional; the issue gets `default_tags` plus these tags, without duplicates
+- When `enabled` is `false`, it creates no issue and returns `nil`
+- Otherwise each call creates a new issue with one HTTP request, in the calling thread: no checksum, no deduplication, no cooldown
+- Returns the created issue as a Hash (the `issue` object from Redmine's response), or `nil` when Errmine gets no created issue back (disabled, or the request or response failed). After a read timeout or an unreadable response, Redmine can still have created the issue. Errmine logs its own failures to stderr and does not raise them
+
 ### Disabling Notifications
 
 ```ruby
@@ -172,29 +207,43 @@ end
 ### Checksum Generation
 
 Each exception gets an 8-character MD5 checksum based on:
+- Application name (`app_name`)
 - Exception class name
 - Exception message
-- First application backtrace line (containing `/app/`)
+- First application backtrace line (containing `/app/`), or the first backtrace line if none contains `/app/`
+
+The same error in two applications with different `app_name` values creates two separate issues.
 
 ```
-MD5("NoMethodError:undefined method 'foo':app/controllers/users_controller.rb:45")[0..7]
+MD5("my-app:NoMethodError:undefined method 'foo':app/controllers/users_controller.rb:45")[0..7]
 # => "a1b2c3d4"
 ```
 
 ### Deduplication
 
 1. Search Redmine for open issues containing `[{checksum}]` in the subject
-2. If found: increment counter, add journal note with timestamp and backtrace
+2. If found: increment the counter in the subject and add a journal note with the new count, the time, `URL:` and `User:` lines when `url` and `user` are set in the context, and the first 10 backtrace lines (see [Journal Note](#journal-note-on-subsequent-occurrences))
 3. If not found: create new issue
 
+The rate limit cache is per process, and the search and the create have no lock across processes. Two processes (for example, two web server workers) that report the same new error at the same time can both find no issue and create two issues.
+
 ### Rate Limiting
 
 To prevent flooding Redmine during error loops:
 
-- Each checksum is cached with its last occurrence time
-- Same error won't hit Redmine more than once per cooldown period (default: 5 minutes)
+- Each checksum is cached with the time of its last report that passed the cooldown; reports inside the cooldown are dropped and do not restart it
+- Same error won't hit Redmine more than once per cooldown period (default: 5 minutes) in each process, unless the report fails
+- When a report fails (HTTP error status, timeout, connection error), Errmine logs one warning to stderr and does not resend that occurrence. The next occurrence of the same error after 60 seconds (or after the cooldown, if it is shorter) is reported, instead of being dropped for the whole cooldown. During a Redmine outage the same error can call Redmine once per 60 seconds or once per cooldown, whichever is shorter, in each process
 - Cache is automatically cleaned when it exceeds 500 entries
 
+### Synchronous Reporting
+
+`Errmine.notify` runs in the thread that reports the error. This includes the Rack middleware and the Rails error subscriber, so the request or job waits until Errmine finishes.
+
+- Each report that passes the cooldown makes up to 2 HTTP requests to Redmine: a search, then a create or an update
+- Each request has a 5-second connect timeout (`CONNECT_TIMEOUT`) and a 10-second read timeout (`READ_TIMEOUT`)
+- Errmine's own failures (timeouts, connection and HTTP errors) never raise into your application: Errmine logs them to stderr and `Errmine.notify` returns `nil`
+
 ## Redmine Setup
 
 1. **Enable REST API**: Administration > Settings > API > Enable REST web service
@@ -211,10 +260,10 @@ To prevent flooding Redmine during error loops:
 ### Subject
 
 ```
-[{checksum}][{count}] {ExceptionClass}: {truncated message}
+[{app_name}][{checksum}][{count}] {ExceptionClass}: {truncated message}
 ```
 
-Example: `[a1b2c3d4][47] NoMethodError: undefined method 'foo' for nil...`
+Example: `[my-app][a1b2c3d4][47] NoMethodError: undefined method 'foo' for nil...`
 
 ### Description (Textile format)
 
@@ -235,18 +284,23 @@ app/controllers/application_controller.rb:12:in `authenticate'
 </pre>
 ```
 
+The `Backtrace` section holds the first 20 backtrace lines, or `No backtrace available` when the exception has no backtrace.
+
 ### Journal Note (on subsequent occurrences)
 
 ```textile
 Occurred again (*47x*) at 2025-01-15 10:35:00
 
 URL: /users/456
+User: user@example.com
 
 <pre>
 app/controllers/users_controller.rb:45:in `show'
 </pre>
 ```
 
+The `URL:` and `User:` lines appear when `url` and `user` are set in the context. Other context keys do not appear in the note.
+
 ## License
 
 MIT License. See [LICENSE](LICENSE) for details.

data/lib/errmine/middleware.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-# @see Errmine
+require 'uri'
+
 module Errmine
   # Rack middleware that catches exceptions and reports them to Redmine.
   # Re-raises the exception after reporting to allow normal error handling.
   class Middleware
+    # Replacement for the value of a filtered query parameter
+    FILTERED = '[FILTERED]'
+
     # Creates a new middleware instance
     #
     # @param app [#call] the Rack application
@@ -45,7 +49,7 @@ module Errmine
       context = {}
 
       request_uri = env['REQUEST_URI'] || env['PATH_INFO']
-      context[:url] = request_uri if request_uri
+      context[:url] = filter_url(request_uri) if request_uri
 
       request_method = env['REQUEST_METHOD']
       context[:method] = request_method if request_method
@@ -57,5 +61,33 @@ module Errmine
 
       context
     end
+
+    # Replaces the values of sensitive query parameters with FILTERED
+    #
+    # @param url [String] the request URI
+    # @return [String] the URI with sensitive query values filtered
+    def filter_url(url)
+      path, query = url.split('?', 2)
+      return url unless query
+
+      pairs = query.split('&', -1).map do |pair|
+        raw_key = pair.split('=', 2).first.to_s
+        filter_key?(URI.decode_www_form_component(raw_key)) ? "#{raw_key}=#{FILTERED}" : pair
+      end
+
+      "#{path}?#{pairs.join('&')}"
+    rescue ArgumentError, EncodingError
+      "#{path}?#{FILTERED}"
+    end
+
+    # Checks if a query parameter name matches a configured filter
+    #
+    # @param key [String] the decoded parameter name
+    # @return [Boolean] true if the value of this parameter must be filtered
+    def filter_key?(key)
+      Errmine.configuration.filter_parameters.any? do |filter|
+        filter.is_a?(Regexp) ? filter.match?(key) : key.downcase.include?(filter.to_s.downcase)
+      end
+    end
   end
 end

data/lib/errmine/notifier.rb

@@ -6,7 +6,6 @@ require 'json'
 require 'digest'
 require 'singleton'
 
-# @see Errmine
 module Errmine
   # Core notifier that handles exception reporting to Redmine.
   # Manages checksum generation, rate limiting, and API communication.
@@ -25,6 +24,14 @@ module Errmine
     # Maximum length of exception message in issue subject
     SUBJECT_MESSAGE_LENGTH = 60
 
+    # Seconds before an error whose report failed is reported again (capped by the cooldown)
+    FAILED_REPORT_RETRY_DELAY = 60
+
+    # Raised internally when a Redmine request fails
+    class RequestError < StandardError; end
+
+    private_constant :FAILED_REPORT_RETRY_DELAY, :RequestError
+
     # Initializes the notifier with empty cache
     def initialize
       @cache = {}
@@ -53,6 +60,10 @@ module Errmine
       else
         update_issue(result, exception, context)
       end
+    rescue RequestError => e
+      retry_delay = schedule_retry(checksum)
+      warn "[Errmine] Failed to report #{exception.class} (#{e.message}), retrying in #{retry_delay}s"
+      nil
     end
 
     # Clears the rate limit cache
@@ -62,6 +73,44 @@ module Errmine
       @mutex.synchronize { @cache.clear }
     end
 
+    # Creates a custom issue in Redmine
+    #
+    # @param subject [String] issue subject/title
+    # @param description [String] issue description (Textile format)
+    # @param options [Hash] optional overrides
+    # @option options [String] :project_id Redmine project identifier
+    # @option options [Integer] :tracker_id Redmine tracker ID
+    # @option options [Array<String>] :tags tags to add to the issue
+    # @option options [Integer] :assigned_to_id Redmine user ID to assign the issue to
+    # @return [Hash, nil] the created issue or nil on failure
+    def create_custom_issue(subject:, description:, **options)
+      uri = build_uri('/issues.json')
+
+      issue_data = {
+        project_id: options[:project_id] || config.project_id,
+        tracker_id: options[:tracker_id] || config.tracker_id,
+        subject: to_utf8(subject),
+        description: to_utf8(description)
+      }
+
+      tags = build_tag_list(options[:tags])
+      issue_data[:tag_list] = tags unless tags.empty?
+
+      assigned_to_id = options[:assigned_to_id] || config.assigned_to_id
+      issue_data[:assigned_to_id] = assigned_to_id if assigned_to_id
+
+      response = http_post(uri, { issue: issue_data })
+
+      data = JSON.parse(response.body)
+      data['issue']
+    rescue JSON::ParserError => e
+      warn "[Errmine] Failed to parse response: #{e.message}"
+      nil
+    rescue RequestError => e
+      warn "[Errmine] #{e.message}"
+      nil
+    end
+
     private
 
     # Returns the Errmine configuration
@@ -71,13 +120,37 @@ module Errmine
       Errmine.configuration
     end
 
+    # Builds a combined tag list from default tags and provided tags
+    #
+    # @param tags [Array<String>, nil] additional tags to include
+    # @return [Array<String>] combined unique tags
+    def build_tag_list(tags)
+      combined = config.default_tags.dup
+      combined.concat(Array(tags)) if tags
+      combined.map { |tag| to_utf8(tag) }.uniq
+    end
+
+    # Converts a value to valid UTF-8 text, replacing invalid and undefined bytes
+    #
+    # @param value [Object]
+    # @return [String]
+    def to_utf8(value)
+      text = value.to_s
+      return text if text.encoding == Encoding::UTF_8 && text.valid_encoding?
+      return text.dup.force_encoding(Encoding::UTF_8).scrub if text.encoding == Encoding::BINARY
+
+      text.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+    rescue EncodingError
+      text.dup.force_encoding(Encoding::UTF_8).scrub
+    end
+
     # Generates an 8-character checksum for the exception
     #
     # @param exception [Exception]
     # @return [String]
     def generate_checksum(exception)
       first_app_line = first_app_backtrace_line(exception)
-      data = "#{exception.class}:#{exception.message}:#{first_app_line}"
+      data = [config.app_name, exception.class, exception.message, first_app_line].map { |part| part.to_s.b }.join(':')
       Digest::MD5.hexdigest(data)[0, 8]
     end
 
@@ -117,6 +190,20 @@ module Errmine
       end
     end
 
+    # Shortens the rate limit of a checksum whose report failed to the retry delay
+    #
+    # @param checksum [String]
+    # @return [Numeric] seconds until the checksum may be reported again
+    def schedule_retry(checksum)
+      retry_delay = [FAILED_REPORT_RETRY_DELAY, config.cooldown].min
+
+      @mutex.synchronize do
+        @cache[checksum] = Time.now - config.cooldown + retry_delay
+      end
+
+      retry_delay
+    end
+
     # Cleans up old entries from the cache
     #
     # @return [void]
@@ -127,14 +214,15 @@ module Errmine
       return unless @cache.size >= MAX_CACHE_SIZE
 
       sorted = @cache.sort_by { |_, time| time }
-      to_remove = sorted.first(@cache.size - (MAX_CACHE_SIZE / 2))
-      to_remove.each_key { |key| @cache.delete(key) }
+      to_remove = sorted.first(@cache.size - (MAX_CACHE_SIZE / 2)).map(&:first)
+      to_remove.each { |key| @cache.delete(key) }
     end
 
     # Finds an existing open issue with the given checksum
     #
     # @param checksum [String]
-    # @return [Hash, Symbol, nil] the issue hash, :error on failure, or nil if not found
+    # @return [Hash, Symbol, nil] the issue hash, :error on an unparsable response, or nil if not found
+    # @raise [RequestError] when the request fails
     def find_existing_issue(checksum)
       uri = build_uri('/issues.json')
       uri.query = URI.encode_www_form(
@@ -144,7 +232,6 @@ module Errmine
       )
 
       response = http_get(uri)
-      return :error unless response
 
       data = JSON.parse(response.body)
       issues = data['issues'] || []
@@ -161,23 +248,27 @@ module Errmine
     # @param context [Hash]
     # @param checksum [String]
     # @return [Hash, nil]
+    # @raise [RequestError] when the request fails
     def create_issue(exception, context, checksum)
       uri = build_uri('/issues.json')
 
       subject = build_subject(checksum, 1, exception)
       description = build_description(exception, context)
 
-      payload = {
-        issue: {
-          project_id: config.project_id,
-          tracker_id: config.tracker_id,
-          subject: subject,
-          description: description
-        }
+      issue_data = {
+        project_id: config.project_id,
+        tracker_id: config.tracker_id,
+        subject: subject,
+        description: description
       }
 
-      response = http_post(uri, payload)
-      return nil unless response
+      tags = build_tag_list(context[:tags])
+      issue_data[:tag_list] = tags unless tags.empty?
+
+      assigned_to_id = context[:assigned_to_id] || config.assigned_to_id
+      issue_data[:assigned_to_id] = assigned_to_id if assigned_to_id
+
+      response = http_post(uri, { issue: issue_data })
 
       data = JSON.parse(response.body)
       data['issue']
@@ -191,7 +282,8 @@ module Errmine
     # @param issue [Hash]
     # @param exception [Exception]
     # @param context [Hash]
-    # @return [Net::HTTPResponse, nil]
+    # @return [Net::HTTPResponse]
+    # @raise [RequestError] when the request fails
     def update_issue(issue, exception, context)
       issue_id = issue['id']
       current_subject = issue['subject']
@@ -221,11 +313,11 @@ module Errmine
     # @param exception [Exception]
     # @return [String]
     def build_subject(checksum, count, exception)
-      message = exception.message.to_s
+      message = to_utf8(exception.message)
       truncated = message.length > SUBJECT_MESSAGE_LENGTH ? "#{message[0, SUBJECT_MESSAGE_LENGTH]}..." : message
       truncated = truncated.gsub(/[\r\n]+/, ' ').strip
 
-      "[#{checksum}][#{count}] #{exception.class}: #{truncated}"
+      "[#{config.app_name}][#{checksum}][#{count}] #{exception.class}: #{truncated}"
     end
 
     # Builds the issue description in Textile format
@@ -236,19 +328,19 @@ module Errmine
     def build_description(exception, context)
       lines = []
       lines << "**Exception:** @#{exception.class}@"
-      lines << "**Message:** #{exception.message}"
+      lines << "**Message:** #{to_utf8(exception.message)}"
       lines << "**App:** #{config.app_name}"
       lines << "**First seen:** #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
       lines << ''
 
-      lines << "**URL:** #{context[:url]}" if context[:url]
+      lines << "**URL:** #{to_utf8(context[:url])}" if context[:url]
 
-      lines << "**User:** #{context[:user]}" if context[:user]
+      lines << "**User:** #{to_utf8(context[:user])}" if context[:user]
 
       context.each do |key, value|
         next if %i[url user].include?(key)
 
-        lines << "**#{key.to_s.capitalize}:** #{value}"
+        lines << "**#{to_utf8(key).capitalize}:** #{to_utf8(value)}"
       end
 
       lines << ''
@@ -272,8 +364,8 @@ module Errmine
       lines << "Occurred again (*#{count}x*) at #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
       lines << ''
 
-      lines << "URL: #{context[:url]}" if context[:url]
-      lines << "User: #{context[:user]}" if context[:user]
+      lines << "URL: #{to_utf8(context[:url])}" if context[:url]
+      lines << "User: #{to_utf8(context[:user])}" if context[:user]
 
       lines << ''
       lines << '<pre>'
@@ -291,7 +383,7 @@ module Errmine
     def format_backtrace(exception, limit: 20)
       return 'No backtrace available' unless exception.backtrace
 
-      exception.backtrace.first(limit).join("\n")
+      exception.backtrace.first(limit).map { |line| to_utf8(line) }.join("\n")
     end
 
     # Extracts the occurrence count from issue subject
@@ -324,7 +416,8 @@ module Errmine
     # Performs an HTTP GET request
     #
     # @param uri [URI]
-    # @return [Net::HTTPResponse, nil]
+    # @return [Net::HTTPResponse]
+    # @raise [RequestError] when the request fails
     def http_get(uri)
       http_request(uri) do |http|
         request = Net::HTTP::Get.new(uri)
@@ -337,7 +430,8 @@ module Errmine
     #
     # @param uri [URI]
     # @param payload [Hash]
-    # @return [Net::HTTPResponse, nil]
+    # @return [Net::HTTPResponse]
+    # @raise [RequestError] when the request fails
     def http_post(uri, payload)
       http_request(uri) do |http|
         request = Net::HTTP::Post.new(uri)
@@ -352,7 +446,8 @@ module Errmine
     #
     # @param uri [URI]
     # @param payload [Hash]
-    # @return [Net::HTTPResponse, nil]
+    # @return [Net::HTTPResponse]
+    # @raise [RequestError] when the request fails
     def http_put(uri, payload)
       http_request(uri) do |http|
         request = Net::HTTP::Put.new(uri)
@@ -363,10 +458,11 @@ module Errmine
       end
     end
 
-    # Executes an HTTP request with error handling
+    # Executes an HTTP request, converting failures into RequestError
     #
     # @param uri [URI]
-    # @return [Net::HTTPResponse, nil]
+    # @return [Net::HTTPResponse]
+    # @raise [RequestError] when the request fails
     def http_request(uri)
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = uri.scheme == 'https'
@@ -375,21 +471,17 @@ module Errmine
 
       response = yield(http)
 
-      unless response.is_a?(Net::HTTPSuccess)
-        warn "[Errmine] HTTP #{response.code}: #{response.message}"
-        return nil
-      end
+      raise RequestError, "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
 
       response
+    rescue RequestError
+      raise
     rescue Net::OpenTimeout, Net::ReadTimeout => e
-      warn "[Errmine] Timeout: #{e.message}"
-      nil
+      raise RequestError, "Timeout: #{e.message}"
     rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError => e
-      warn "[Errmine] Connection error: #{e.message}"
-      nil
+      raise RequestError, "Connection error: #{e.message}"
     rescue StandardError => e
-      warn "[Errmine] HTTP error: #{e.message}"
-      nil
+      raise RequestError, "HTTP error: #{e.message}"
     end
   end
 end

data/lib/errmine/railtie.rb

@@ -2,7 +2,6 @@
 
 require_relative 'middleware'
 
-# @see Errmine
 module Errmine
   # Rails integration via Railtie.
   # Automatically subscribes to Rails 7+ Error Reporting API when available.
@@ -11,6 +10,14 @@ module Errmine
       Rails.error.subscribe(ErrorSubscriber.new) if Rails.version >= '7.0'
     end
 
+    config.after_initialize do |app|
+      rails_filters = app.config.filter_parameters.select do |filter|
+        filter.is_a?(String) || filter.is_a?(Symbol) || filter.is_a?(Regexp)
+      end
+
+      Errmine.configuration.filter_parameters |= rails_filters
+    end
+
     # Error subscriber for Rails 7+ Error Reporting API
     class ErrorSubscriber
       # Called by Rails when an error is reported

data/lib/errmine/version.rb

@@ -2,5 +2,5 @@
 
 module Errmine
   # Current version of the errmine gem
-  VERSION = '0.1.1'
+  VERSION = '0.3.0'
 end

data/lib/errmine.rb

@@ -29,21 +29,33 @@ module Errmine
     # @return [String] Application name shown in issues
     attr_accessor :app_name
 
+    # @return [Array<String>] Default tags to add to all issues
+    attr_accessor :default_tags
+
+    # @return [Integer, nil] Redmine user ID new issues are assigned to (nil: project default)
+    attr_accessor :assigned_to_id
+
     # @return [Boolean] Whether notifications are enabled
     attr_accessor :enabled
 
     # @return [Integer] Cooldown period in seconds between same-error notifications
     attr_accessor :cooldown
 
+    # @return [Array<String, Symbol, Regexp>] Query parameter names whose values the middleware filters
+    attr_accessor :filter_parameters
+
     # Initializes configuration with defaults from environment variables
     def initialize
-      @redmine_url = ENV.fetch('ERRMINE_REDMINE_URL', nil)
-      @api_key     = ENV.fetch('ERRMINE_API_KEY', nil)
-      @project_id  = ENV['ERRMINE_PROJECT'] || 'bug-tracker'
-      @tracker_id  = 1
-      @app_name    = ENV['ERRMINE_APP_NAME'] || 'unknown'
-      @enabled     = true
-      @cooldown    = 300
+      @redmine_url  = ENV.fetch('ERRMINE_REDMINE_URL', nil)
+      @api_key      = ENV.fetch('ERRMINE_API_KEY', nil)
+      @project_id   = ENV['ERRMINE_PROJECT'] || 'bug-tracker'
+      @tracker_id   = 1
+      @app_name     = ENV['ERRMINE_APP_NAME'] || 'unknown'
+      @default_tags = []
+      @enabled      = true
+      @cooldown     = 300
+      @assigned_to_id = nil
+      @filter_parameters = %w[passw email secret token _key crypt salt certificate otp ssn cvv cvc]
     end
 
     # Checks if the configuration has required values
@@ -93,6 +105,26 @@ module Errmine
       warn "[Errmine] Failed to notify: #{e.message}"
       nil
     end
+
+    # Creates a custom issue in Redmine
+    #
+    # @param subject [String] issue subject/title
+    # @param description [String] issue description (Textile format)
+    # @param options [Hash] optional keyword arguments
+    # @option options [String] :project_id Redmine project identifier
+    # @option options [Integer] :tracker_id Redmine tracker ID
+    # @option options [Array<String>] :tags tags to add to the issue
+    # @option options [Integer] :assigned_to_id Redmine user ID to assign the issue to
+    # @return [Hash, nil] the created issue or nil on failure
+    def create_issue(subject:, description:, **options)
+      return unless configuration.enabled
+      return unless configuration.valid?
+
+      Notifier.instance.create_custom_issue(subject: subject, description: description, **options)
+    rescue StandardError => e
+      warn "[Errmine] Failed to create issue: #{e.message}"
+      nil
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: errmine
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -29,8 +29,11 @@ homepage: https://github.com/mensfeld/errmine
 licenses:
 - MIT
 metadata:
+  homepage_uri: https://github.com/mensfeld/errmine
   source_code_uri: https://github.com/mensfeld/errmine
   changelog_uri: https://github.com/mensfeld/errmine/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/mensfeld/errmine/issues
+  documentation_uri: https://github.com/mensfeld/errmine
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -39,14 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Dead simple exception tracking for Redmine
 test_files: []