prometheus_exporter 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '042907307e8e1555111f34fb69d6cf66127e7742a76130952e3708a742ada24a'
-  data.tar.gz: 1e474618e9ddfa870a47e3ba7d7e55935677f3770d73968bb60457474b49502d
+  metadata.gz: e8f8c9307f755aa00e95f323d2be11cdf6830f7e420c9bf70d90260e9bc81a85
+  data.tar.gz: 216bedbba838f0a84391ef2e85b290aa596cf3c42d27b4cc6bce7a9fae8be01d
 SHA512:
-  metadata.gz: '0137930945e0b254dbf0d7245d696d782044bfee9dd255ff022ffadaddafb47cdefc1aa6f83927bc84866d87fee761027590c2f08fbe730496e7099e68a883b7'
-  data.tar.gz: 562691a91a7f4a0e380b92236f3295177481763393db7b0db9d8763f6ac631d317e6bd21bd3368471029742b8e649a1c2a3884fa2aafe93d280aa353909d9ecd
+  metadata.gz: 3ad534e47314779c76eb9e80d5de23619cd0865c2337147188d7f2ddba3bff9a6c9cf630e20720899c4e7ef9c95bf1db317a719d08fc241850f902aceae1b5cf
+  data.tar.gz: 6e71eab8cf6cdb049612c5afc404d6e399a142ee3eb5bbb3ae897e374ac6474d09f1b6c3ad94ab31f8d12fc52fc9e609a8b066051c89e44ea84be0fa0ec2cf0e

data/.github/workflows/ci.yml

@@ -27,20 +27,24 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['3.0', '3.1', '3.2', '3.3']
-        activerecord: [60, 61, 70]
+        ruby: ["3.1", "3.2", "3.3"]
+        activerecord: [61, 70, 71]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
+          bundler: latest
           bundler-cache: true
 
       - name: Rubocop
         run: bundle exec rubocop
 
+      - name: Syntax tree
+        run: bundle exec stree check Gemfile $(git ls-files '*.rb') $(git ls-files '*.rake') $(git ls-files '*.thor')
+
       - name: Run tests
         run: bundle exec rake
 
@@ -50,10 +54,10 @@ jobs:
     runs-on: ubuntu-latest
 
     outputs:
-      new_version_published: ${{ steps.release.outputs.new_version_published }}
+      new_version_published: ${{ steps.release.outputs.new_version }}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Release gem
         id: release
@@ -70,7 +74,7 @@ jobs:
     timeout-minutes: 20
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: docker/setup-qemu-action@v2
       - uses: docker/setup-buildx-action@v2
 

data/.rubocop

@@ -0,0 +1 @@
+--ignore-unrecognized-cops

data/.rubocop.yml

@@ -4,4 +4,15 @@ inherit_gem:
 AllCops:
   Exclude:
     - 'gemfiles/**/*'
-    - 'vendor/**/*'
+    - 'vendor/**/*'
+
+Discourse/Plugins/NoMonkeyPatching:
+  Enabled: false
+
+Discourse/Plugins/NamespaceMethods:
+  Exclude:
+    - bin/prometheus_exporter
+
+Style/InvertibleUnlessCondition:
+  Exclude:
+    - '*.gemspec' 

data/.streerc

@@ -0,0 +1,2 @@
+--print-width=100
+--plugins=plugin/trailing_comma,disable_ternary

data/CHANGELOG

@@ -1,4 +1,15 @@
-2.1.0 - 2024-08-01
+2.2.0 - 2024-12-05
+
+- FIX: Ensure socket is closed when error is raised while opening socket
+- Feature: Add Dalli::Client memcache metrics for web_collector
+
+2.1.1 - 2024-06-19
+
+- FEATURE: improve good_job instrumentation
+- FIX: improve Ruby 3.X support
+- FEATURE: imstrumentation for malloc / oldmalloc increace in GC stats
+
+2.1.0 - 2024-01-08
 
 - FEATURE: good_job instrumentation
 - PERF: improve performance of histogram

data/README.md

@@ -40,7 +40,7 @@ To learn more see [Instrumenting Rails with Prometheus](https://samsaffron.com/a
 
 ## Requirements
 
-Minimum Ruby of version 2.6.0 is required, Ruby 2.5.0 is EOL as of March 31st 2021.
+Minimum Ruby of version 3.0.0 is required, Ruby 2.7 is EOL as of March 31st 2023.
 
 ## Migrating from v0.x
 
@@ -213,13 +213,14 @@ Rails.application.middleware.unshift PrometheusExporter::Middleware, instrument:
 
 #### Metrics collected by Rails integration middleware
 
-| Type    | Name                                   | Description                                                 |
-| ---     | ---                                    | ---                                                         |
-| Counter | `http_requests_total`                  | Total HTTP requests from web app                            |
-| Summary | `http_request_duration_seconds`        | Time spent in HTTP reqs in seconds                          |
-| Summary | `http_request_redis_duration_seconds`¹ | Time spent in HTTP reqs in Redis, in seconds                |
-| Summary | `http_request_sql_duration_seconds`²   | Time spent in HTTP reqs in SQL in seconds                   |
-| Summary | `http_request_queue_duration_seconds`³ | Time spent queueing the request in load balancer in seconds |
+| Type    | Name                                      | Description                                                 |
+| ---     | ---                                       | ---                                                         |
+| Counter | `http_requests_total`                     | Total HTTP requests from web app                            |
+| Summary | `http_request_duration_seconds`           | Time spent in HTTP reqs in seconds                          |
+| Summary | `http_request_redis_duration_seconds`¹    | Time spent in HTTP reqs in Redis, in seconds                |
+| Summary | `http_request_sql_duration_seconds`²      | Time spent in HTTP reqs in SQL in seconds                   |
+| Summary | `http_request_queue_duration_seconds`³    | Time spent queueing the request in load balancer in seconds |
+| Summary | `http_request_memcache_duration_seconds`⁴ | Time spent in HTTP reqs in Memcache in seconds              |
 
 All metrics have a `controller` and an `action` label.
 `http_requests_total` additionally has a (HTTP response) `status` label.
@@ -268,6 +269,7 @@ ruby_http_request_duration_seconds{path="/api/v1/teams/:id",method="GET",status=
 ¹) Only available when Redis is used.
 ²) Only available when Mysql or PostgreSQL are used.
 ³) Only available when [Instrumenting Request Queueing Time](#instrumenting-request-queueing-time) is set up.
+⁴) Only available when Dalli is used.
 
 #### Activerecord Connection Pool Metrics
 
@@ -583,6 +585,17 @@ The puma metrics are using the `Puma.stats` method and hence need to be started
 workers has been booted and from a Puma thread otherwise the metrics won't be accessible.
 The easiest way to gather this metrics is to put the following in your `puma.rb` config:
 
+For Puma single mode
+```ruby
+# puma.rb config
+require 'prometheus_exporter/instrumentation'
+# optional check, avoids spinning up and down threads per worker
+if !PrometheusExporter::Instrumentation::Puma.started?
+  PrometheusExporter::Instrumentation::Puma.start
+end
+```
+
+For Puma clustered mode
 ```ruby
 # puma.rb config
 after_worker_boot do
@@ -884,7 +897,7 @@ prometheus_exporter -p 8080 \
                     --prefix 'foo_'
 ```
 
-You can use `-b` option to bind the `prometheus_exporter` web server to any IPv4 interface with `-b 0.0.0.0`, 
+You can use `-b` option to bind the `prometheus_exporter` web server to any IPv4 interface with `-b 0.0.0.0`,
 any IPv6 interface with `-b ::`, or `-b ANY` to any IPv4/IPv6 interfaces available on your host system.
 
 #### Enabling Basic Authentication

data/bench/bench.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../lib/prometheus_exporter'
-require_relative '../lib/prometheus_exporter/client'
-require_relative '../lib/prometheus_exporter/server'
+require_relative "../lib/prometheus_exporter"
+require_relative "../lib/prometheus_exporter/client"
+require_relative "../lib/prometheus_exporter/server"
 
 # test how long it takes a custom collector to process 10k messages
 
@@ -26,18 +26,19 @@ end
 @client = nil
 @runs = 1000
 
-done = lambda do
-  puts "Elapsed for 10k messages is #{Time.now - @start}"
-  if (@runs -= 1) > 0
-    @start = Time.now
-    10_000.times { @client.send_json(hello: "world") }
+done =
+  lambda do
+    puts "Elapsed for 10k messages is #{Time.now - @start}"
+    if (@runs -= 1) > 0
+      @start = Time.now
+      10_000.times { @client.send_json(hello: "world") }
+    end
   end
-end
 
 collector = Collector.new(done)
-server = PrometheusExporter::Server::WebServer.new port: 12349, collector: collector
+server = PrometheusExporter::Server::WebServer.new port: 12_349, collector: collector
 server.start
-@client = PrometheusExporter::Client.new port: 12349, max_queue_size: 100_000
+@client = PrometheusExporter::Client.new port: 12_349, max_queue_size: 100_000
 
 @start = Time.now
 10_000.times { @client.send_json(hello: "world") }

data/bin/prometheus_exporter

@@ -74,7 +74,7 @@ def run
   end.parse!
 
   logger = Logger.new(options[:logger_path])
-  logger.level = Logger::WARN
+  logger.level = Logger::INFO
 
   if options.has_key?(:realm) && !options.has_key?(:auth)
     logger.warn "Providing REALM without AUTH has no effect"
@@ -121,7 +121,7 @@ def run
 
   runner = PrometheusExporter::Server::Runner.new(options)
 
-  puts "#{Time.now} Starting prometheus exporter on #{runner.bind}:#{runner.port}"
+  logger.info "Starting prometheus exporter on #{runner.bind}:#{runner.port}"
   runner.start
   sleep
 end

data/examples/custom_collector.rb

@@ -20,8 +20,6 @@ class MyCustomCollector < PrometheusExporter::Server::BaseCollector
   end
 
   def prometheus_metrics_text
-    @mutex.synchronize do
-      "#{@gauge1.to_prometheus_text}\n#{@gauge2.to_prometheus_text}"
-    end
+    @mutex.synchronize { "#{@gauge1.to_prometheus_text}\n#{@gauge2.to_prometheus_text}" }
   end
 end

data/gemfiles/ar_70.gemfile

@@ -2,4 +2,6 @@
 
 source "https://rubygems.org"
 
+gem "activerecord", "~> 7.0.0"
+
 gemspec path: "../"

data/gemfiles/ar_71.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.1.0"
+
+gemspec path: "../"

data/lib/prometheus_exporter/client.rb

@@ -17,13 +17,7 @@ module PrometheusExporter
       end
 
       def standard_values(value, keys, prometheus_exporter_action = nil)
-        values = {
-          type: @type,
-          help: @help,
-          name: @name,
-          keys: keys,
-          value: value
-        }
+        values = { type: @type, help: @help, name: @name, keys: keys, value: value }
         values[
           :prometheus_exporter_action
         ] = prometheus_exporter_action if prometheus_exporter_action
@@ -59,16 +53,14 @@ module PrometheusExporter
 
     def initialize(
       host: ENV.fetch("PROMETHEUS_EXPORTER_HOST", "localhost"),
-      port: ENV.fetch(
-        "PROMETHEUS_EXPORTER_PORT",
-        PrometheusExporter::DEFAULT_PORT
-      ),
+      port: ENV.fetch("PROMETHEUS_EXPORTER_PORT", PrometheusExporter::DEFAULT_PORT),
       max_queue_size: nil,
       thread_sleep: 0.5,
       json_serializer: nil,
       custom_labels: nil,
       logger: Logger.new(STDERR),
-      log_level: Logger::WARN
+      log_level: Logger::WARN,
+      process_queue_once_and_stop: false
     )
       @logger = logger
       @logger.level = log_level
@@ -83,9 +75,7 @@ module PrometheusExporter
       max_queue_size ||= MAX_QUEUE_SIZE
       max_queue_size = max_queue_size.to_i
 
-      if max_queue_size <= 0
-        raise ArgumentError, "max_queue_size must be larger than 0"
-      end
+      raise ArgumentError, "max_queue_size must be larger than 0" if max_queue_size <= 0
 
       @max_queue_size = max_queue_size
       @host = host
@@ -94,10 +84,10 @@ module PrometheusExporter
       @mutex = Mutex.new
       @thread_sleep = thread_sleep
 
-      @json_serializer =
-        json_serializer == :oj ? PrometheusExporter::OjCompat : JSON
+      @json_serializer = json_serializer == :oj ? PrometheusExporter::OjCompat : JSON
 
       @custom_labels = custom_labels
+      @process_queue_once_and_stop = process_queue_once_and_stop
     end
 
     def custom_labels=(custom_labels)
@@ -105,14 +95,7 @@ module PrometheusExporter
     end
 
     def register(type, name, help, opts = nil)
-      metric =
-        RemoteMetric.new(
-          type: type,
-          name: name,
-          help: help,
-          client: self,
-          opts: opts
-        )
+      metric = RemoteMetric.new(type: type, name: name, help: help, client: self, opts: opts)
       @metrics << metric
       metric
     end
@@ -163,7 +146,7 @@ module PrometheusExporter
           @socket.write("\r\n")
         rescue => e
           logger.warn "Prometheus Exporter is dropping a message: #{e}"
-          @socket = nil
+          close_socket!
           raise
         end
       end
@@ -189,6 +172,11 @@ module PrometheusExporter
     end
 
     def ensure_worker_thread!
+      if @process_queue_once_and_stop
+        worker_loop
+        return
+      end
+
       unless @worker_thread&.alive?
         @mutex.synchronize do
           return if @worker_thread&.alive?
@@ -253,8 +241,7 @@ module PrometheusExporter
 
       nil
     rescue StandardError
-      @socket = nil
-      @socket_started = nil
+      close_socket!
       @socket_pid = nil
       raise
     end
@@ -262,10 +249,7 @@ module PrometheusExporter
     def wait_for_empty_queue_with_timeout(timeout_seconds)
       start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       while @queue.length > 0
-        if start_time + timeout_seconds <
-             ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-          break
-        end
+        break if start_time + timeout_seconds < ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         sleep(0.05)
       end
     end

data/lib/prometheus_exporter/instrumentation/active_record.rb

@@ -3,14 +3,16 @@
 # collects stats from currently running process
 module PrometheusExporter::Instrumentation
   class ActiveRecord < PeriodicStats
-    ALLOWED_CONFIG_LABELS = %i(database username host port)
+    ALLOWED_CONFIG_LABELS = %i[database username host port]
 
     def self.start(client: nil, frequency: 30, custom_labels: {}, config_labels: [])
       client ||= PrometheusExporter::Client.default
 
       # Not all rails versions support connection pool stats
       unless ::ActiveRecord::Base.connection_pool.respond_to?(:stat)
-        client.logger.error("ActiveRecord connection pool stats not supported in your rails version")
+        client.logger.error(
+          "ActiveRecord connection pool stats not supported in your rails version",
+        )
         return
       end
 
@@ -29,7 +31,9 @@ module PrometheusExporter::Instrumentation
 
     def self.validate_config_labels(config_labels)
       return if config_labels.size == 0
-      raise "Invalid Config Labels, available options #{ALLOWED_CONFIG_LABELS}" if (config_labels - ALLOWED_CONFIG_LABELS).size > 0
+      if (config_labels - ALLOWED_CONFIG_LABELS).size > 0
+        raise "Invalid Config Labels, available options #{ALLOWED_CONFIG_LABELS}"
+      end
     end
 
     def initialize(metric_labels, config_labels)
@@ -55,7 +59,7 @@ module PrometheusExporter::Instrumentation
           pid: pid,
           type: "active_record",
           hostname: ::PrometheusExporter.hostname,
-          metric_labels: labels(pool)
+          metric_labels: labels(pool),
         }
         metric.merge!(pool.stat)
         metrics << metric
@@ -66,12 +70,20 @@ module PrometheusExporter::Instrumentation
 
     def labels(pool)
       if ::ActiveRecord.version < Gem::Version.new("6.1.0.rc1")
-        @metric_labels.merge(pool_name: pool.spec.name).merge(pool.spec.config
-          .select { |k, v| @config_labels.include? k }
-          .map { |k, v| [k.to_s.dup.prepend("dbconfig_"), v] }.to_h)
+        @metric_labels.merge(pool_name: pool.spec.name).merge(
+          pool
+            .spec
+            .config
+            .select { |k, v| @config_labels.include? k }
+            .map { |k, v| [k.to_s.dup.prepend("dbconfig_"), v] }
+            .to_h,
+        )
       else
         @metric_labels.merge(pool_name: pool.db_config.name).merge(
-          @config_labels.each_with_object({}) { |l, acc| acc["dbconfig_#{l}"] = pool.db_config.public_send(l) })
+          @config_labels.each_with_object({}) do |l, acc|
+            acc["dbconfig_#{l}"] = pool.db_config.public_send(l)
+          end,
+        )
       end
     end
   end

data/lib/prometheus_exporter/instrumentation/delayed_job.rb

@@ -2,23 +2,33 @@
 
 module PrometheusExporter::Instrumentation
   class DelayedJob
-    JOB_CLASS_REGEXP = %r{job_class: (\w+:{0,2})+}.freeze
+    JOB_CLASS_REGEXP = /job_class: ((\w+:{0,2})+)/.freeze
 
     class << self
-      def register_plugin(client: nil)
+      def register_plugin(client: nil, include_module_name: false)
         instrumenter = self.new(client: client)
         return unless defined?(Delayed::Plugin)
 
-        plugin = Class.new(Delayed::Plugin) do
-          callbacks do |lifecycle|
-            lifecycle.around(:invoke_job) do |job, *args, &block|
-              max_attempts = Delayed::Worker.max_attempts
-              enqueued_count = Delayed::Job.where(queue: job.queue).count
-              pending_count = Delayed::Job.where(attempts: 0, locked_at: nil, queue: job.queue).count
-              instrumenter.call(job, max_attempts, enqueued_count, pending_count, *args, &block)
+        plugin =
+          Class.new(Delayed::Plugin) do
+            callbacks do |lifecycle|
+              lifecycle.around(:invoke_job) do |job, *args, &block|
+                max_attempts = Delayed::Worker.max_attempts
+                enqueued_count = Delayed::Job.where(queue: job.queue).count
+                pending_count =
+                  Delayed::Job.where(attempts: 0, locked_at: nil, queue: job.queue).count
+                instrumenter.call(
+                  job,
+                  max_attempts,
+                  enqueued_count,
+                  pending_count,
+                  include_module_name,
+                  *args,
+                  &block
+                )
+              end
             end
           end
-        end
 
         Delayed::Worker.plugins << plugin
       end
@@ -28,7 +38,7 @@ module PrometheusExporter::Instrumentation
       @client = client || PrometheusExporter::Client.default
     end
 
-    def call(job, max_attempts, enqueued_count, pending_count, *args, &block)
+    def call(job, max_attempts, enqueued_count, pending_count, include_module_name, *args, &block)
       success = false
       start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       latency = Time.current - job.run_at
@@ -41,7 +51,7 @@ module PrometheusExporter::Instrumentation
 
       @client.send_json(
         type: "delayed_job",
-        name: job.handler.to_s.match(JOB_CLASS_REGEXP).to_a[1].to_s,
+        name: job.handler.to_s.match(JOB_CLASS_REGEXP).to_a[include_module_name ? 1 : 2].to_s,
         queue_name: job.queue,
         success: success,
         duration: duration,
@@ -49,7 +59,7 @@ module PrometheusExporter::Instrumentation
         attempts: attempts,
         max_attempts: max_attempts,
         enqueued: enqueued_count,
-        pending: pending_count
+        pending: pending_count,
       )
     end
   end

data/lib/prometheus_exporter/instrumentation/good_job.rb

@@ -7,9 +7,7 @@ module PrometheusExporter::Instrumentation
       good_job_collector = new
       client ||= PrometheusExporter::Client.default
 
-      worker_loop do
-        client.send_json(good_job_collector.collect)
-      end
+      worker_loop { client.send_json(good_job_collector.collect) }
 
       super
     end
@@ -23,7 +21,7 @@ module PrometheusExporter::Instrumentation
         running: ::GoodJob::Job.running.size,
         finished: ::GoodJob::Job.finished.size,
         succeeded: ::GoodJob::Job.succeeded.size,
-        discarded: ::GoodJob::Job.discarded.size
+        discarded: ::GoodJob::Job.discarded.size,
       }
     end
   end

data/lib/prometheus_exporter/instrumentation/hutch.rb

@@ -19,7 +19,7 @@ module PrometheusExporter::Instrumentation
         type: "hutch",
         name: @klass.class.to_s,
         success: success,
-        duration: duration
+        duration: duration,
       )
     end
   end

data/lib/prometheus_exporter/instrumentation/method_profiler.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 # see https://samsaffron.com/archive/2017/10/18/fastest-way-to-profile-a-method-in-ruby
-module PrometheusExporter::Instrumentation; end
+module PrometheusExporter::Instrumentation
+end
 
 class PrometheusExporter::Instrumentation::MethodProfiler
   def self.patch(klass, methods, name, instrument:)
@@ -21,9 +22,8 @@ class PrometheusExporter::Instrumentation::MethodProfiler
   end
 
   def self.start(transfer = nil)
-    Thread.current[:_method_profiler] = transfer || {
-      __start: Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    }
+    Thread.current[:_method_profiler] = transfer ||
+      { __start: Process.clock_gettime(Process::CLOCK_MONOTONIC) }
   end
 
   def self.clear
@@ -42,9 +42,9 @@ class PrometheusExporter::Instrumentation::MethodProfiler
 
   def self.define_methods_on_module(klass, methods, name)
     patch_source_line = __LINE__ + 3
-    patches = methods.map do |method_name|
-      <<~RUBY
-        def #{method_name}(*args, &blk)
+
+    patches = methods.map { |method_name| <<~RUBY }.join("\n")
+        def #{method_name}(...)
           unless prof = Thread.current[:_method_profiler]
             return super
           end
@@ -58,9 +58,8 @@ class PrometheusExporter::Instrumentation::MethodProfiler
           end
         end
       RUBY
-    end.join("\n")
 
-    klass.module_eval patches, __FILE__, patch_source_line
+    klass.module_eval(patches, __FILE__, patch_source_line)
   end
 
   def self.patch_using_prepend(klass, methods, name)
@@ -71,17 +70,19 @@ class PrometheusExporter::Instrumentation::MethodProfiler
 
   def self.patch_using_alias_method(klass, methods, name)
     patch_source_line = __LINE__ + 3
-    patches = methods.map do |method_name|
-      <<~RUBY
+
+    patches = methods.map { |method_name| <<~RUBY }.join("\n")
       unless defined?(#{method_name}__mp_unpatched)
         alias_method :#{method_name}__mp_unpatched, :#{method_name}
-        def #{method_name}(*args, &blk)
+
+        def #{method_name}(...)
           unless prof = Thread.current[:_method_profiler]
-            return #{method_name}__mp_unpatched(*args, &blk)
+            return #{method_name}__mp_unpatched(...)
           end
+
           begin
             start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            #{method_name}__mp_unpatched(*args, &blk)
+            #{method_name}__mp_unpatched(...)
           ensure
             data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
             data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
@@ -90,8 +91,7 @@ class PrometheusExporter::Instrumentation::MethodProfiler
         end
       end
       RUBY
-    end.join("\n")
 
-    klass.class_eval patches, __FILE__, patch_source_line
+    klass.class_eval(patches, __FILE__, patch_source_line)
   end
 end