newrelic_security 0.1.0

data/lib/newrelic_security/instrumentation-security/active_record/sqlite3_adapter/instrumentation.rb

@@ -0,0 +1,187 @@
+require_relative 'prepend'
+require_relative 'chain'
+
+module NewRelic::Security
+  module Instrumentation
+    module ActiveRecord::ConnectionAdapters::SQLite3Adapter
+
+      def execute_on_enter(sql, name)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        hash = {}
+        hash[:sql] = sql  #sql query
+        hash[:parameters] = []
+        event = NewRelic::Security::Agent::Control::Collector.collect(SQL_DB_COMMAND, [hash], SQLITE) unless NewRelic::Security::Instrumentation::InstrumentationUtils.sql_filter_events?(hash[:sql])
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def execute_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+      def exec_query_on_enter(*var, **key_vars)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        type_casted_binds = []
+        binds = var[2] #third arg
+        if !binds.nil? && !binds.empty? #if bind params present
+          binds.each { |x|
+            if x.is_a? Integer or x.is_a? String
+              type_casted_binds << x
+            elsif x.is_a? Array and x[0].is_a? ::ActiveRecord::ConnectionAdapters::Column
+              type_casted_binds << x[1].to_s
+            else
+              type_casted_binds << x.value_before_type_cast.to_s
+            end
+          }
+          # binds_copy = binds.clone  #it is a shallow copy
+          # type_casted_binds = type_casted_binds(binds_copy.to_s)
+        end
+        hash = {}
+        hash[:sql] = var[0]  #sql query
+        hash[:parameters] = type_casted_binds #bind params
+        event = NewRelic::Security::Agent::Control::Collector.collect(SQL_DB_COMMAND, [hash], SQLITE) unless NewRelic::Security::Instrumentation::InstrumentationUtils.sql_filter_events?(hash[:sql])
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def exec_query_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+      def internal_exec_query_on_enter(*var, **key_vars)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        type_casted_binds = []
+        binds = var[2] #third arg
+        if !binds.nil? && !binds.empty? #if bind params present
+          binds.each { |x|
+            if x.is_a? Integer or x.is_a? String
+              type_casted_binds << x
+            elsif x.is_a? Array and x[0].is_a? ::ActiveRecord::ConnectionAdapters::Column
+              type_casted_binds << x[1].to_s
+            else
+              type_casted_binds << x.value_before_type_cast.to_s
+            end
+          }
+          # binds_copy = binds.clone  #it is a shallow copy
+          # type_casted_binds = type_casted_binds(binds_copy.to_s)
+        end
+        hash = {}
+        hash[:sql] = var[0]  #sql query
+        hash[:parameters] = type_casted_binds #bind params
+        event = NewRelic::Security::Agent::Control::Collector.collect(SQL_DB_COMMAND, [hash], SQLITE) unless NewRelic::Security::Instrumentation::InstrumentationUtils.sql_filter_events?(hash[:sql])
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def internal_exec_query_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+      def exec_update_on_enter(*var, **key_vars)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        type_casted_binds = []
+        binds = var[2] #third arg
+        if !binds.nil? && !binds.empty? #if bind params present
+          binds.each { |x|
+            if x.is_a? Integer or x.is_a? String
+              type_casted_binds << x
+            elsif x.is_a? Array and x[0].is_a? ::ActiveRecord::ConnectionAdapters::Column
+              type_casted_binds << x[1].to_s
+            else
+              type_casted_binds << x.value_before_type_cast.to_s
+            end
+          }
+          # binds_copy = binds.clone  #it is a shallow copy
+          # type_casted_binds = type_casted_binds(binds_copy.to_s)
+        end
+        hash = {}
+        hash[:sql] = var[0]  #sql query
+        hash[:parameters] = type_casted_binds #bind params
+        event = NewRelic::Security::Agent::Control::Collector.collect(SQL_DB_COMMAND, [hash], SQLITE) unless NewRelic::Security::Instrumentation::InstrumentationUtils.sql_filter_events?(hash[:sql])
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def exec_update_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+      def exec_delete_on_enter(*var, **key_vars)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        type_casted_binds = []
+        binds = var[2] #third arg
+        if !binds.nil? && !binds.empty? #if bind params present
+          binds.each { |x|
+            if x.is_a? Integer or x.is_a? String
+              type_casted_binds << x
+            elsif x.is_a? Array and x[0].is_a? ::ActiveRecord::ConnectionAdapters::Column
+              type_casted_binds << x[1].to_s
+            else
+              type_casted_binds << x.value_before_type_cast.to_s
+            end
+          }
+          # binds_copy = binds.clone  #it is a shallow copy
+          # type_casted_binds = type_casted_binds(binds_copy.to_s)
+        end
+        hash = {}
+        hash[:sql] = var[0]  #sql query
+        hash[:parameters] = type_casted_binds #bind params
+        event = NewRelic::Security::Agent::Control::Collector.collect(SQL_DB_COMMAND, [hash], SQLITE) unless NewRelic::Security::Instrumentation::InstrumentationUtils.sql_filter_events?(hash[:sql])
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def exec_delete_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+    end
+  end
+end
+
+NewRelic::Security::Instrumentation::InstrumentationLoader.install_instrumentation(:sqlite3_adapter, ::ActiveRecord::ConnectionAdapters::SQLite3Adapter, ::NewRelic::Security::Instrumentation::ActiveRecord::ConnectionAdapters::SQLite3Adapter)

data/lib/newrelic_security/instrumentation-security/active_record/sqlite3_adapter/prepend.rb

@@ -0,0 +1,54 @@
+module NewRelic::Security
+  module Instrumentation
+    module ActiveRecord
+      module ConnectionAdapters
+        module SQLite3Adapter
+          module Prepend
+            include NewRelic::Security::Instrumentation::ActiveRecord::ConnectionAdapters::SQLite3Adapter
+
+            if RUBY_ENGINE == 'jruby'
+              def execute(sql, name = nil)
+                retval = nil
+                event = execute_on_enter(sql, name) { retval = super }
+                execute_on_exit(event) { return retval }
+              end
+
+              def exec_update(*var)
+                retval = nil
+                event = exec_update_on_enter(*var) { retval = super }
+                exec_update_on_exit(event) { return retval }
+              end
+
+              def exec_delete(*var)
+                retval = nil
+                event = exec_delete_on_enter(*var) { retval = super }
+                exec_delete_on_exit(event) { return retval }
+              end
+            end
+
+            if ::Rails.version < '5'
+              def exec_query(*var)
+                retval = nil
+                event = exec_query_on_enter(*var) { retval = super }
+                exec_query_on_exit(event) { return retval }
+              end
+            else
+              def exec_query(*var, **key_vars)
+                retval = nil
+                event = exec_query_on_enter(*var, **key_vars) { retval = super }
+                exec_query_on_exit(event) { return retval }
+              end
+
+              def internal_exec_query(*var, **key_vars)
+                retval = nil
+                event = internal_exec_query_on_enter(*var, **key_vars) { retval = super }
+                internal_exec_query_on_exit(event) { return retval }
+              end
+            end
+    
+          end
+        end
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/async-http/chain.rb

@@ -0,0 +1,21 @@
+module NewRelic::Security
+  module Instrumentation
+    module AsyncHttp
+      module Chain
+        def self.instrument!
+          ::Async::HTTP::Internet.class_eval do
+            include NewRelic::Security::Instrumentation::AsyncHttp
+
+            alias_method :call_without_security, :call
+  
+            def call(method, url, headers = nil, body = nil)
+              retval = nil
+              event = call_on_enter(method, url, headers, body) { retval = call_without_security(method, url, headers, body) }
+              call_on_exit(event) { return retval }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/async-http/instrumentation.rb

@@ -0,0 +1,46 @@
+require_relative 'prepend'
+require_relative 'chain'
+require 'uri'
+
+module NewRelic::Security
+  module Instrumentation
+    module AsyncHttp
+
+      def call_on_enter(method, url, headers, body)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        ob = {}
+        ob[:Method] = method
+        uri = ::URI.parse url
+        ob[:scheme]  = uri.scheme
+        ob[:host]    = uri.host
+        ob[:port]    = uri.port
+        ob[:URI]     = uri.to_s
+        ob[:path]    = uri.path
+        ob[:query]   = uri.query
+        ob[:Body] = body.respond_to?(:join) ? body.join.to_s : body.to_s
+        ob[:Headers] = headers.to_h
+        ob.each { |_, value| value.dup.force_encoding(ISO_8859_1).encode(UTF_8) if value.is_a?(String) }
+        event = NewRelic::Security::Agent::Control::Collector.collect(HTTP_REQUEST, [ob])
+        NewRelic::Security::Instrumentation::InstrumentationUtils.append_tracing_data(headers, event) if event
+        event
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def call_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+    end
+  end
+end
+
+NewRelic::Security::Instrumentation::InstrumentationLoader.install_instrumentation(:async_http, ::Async::HTTP::Internet, ::NewRelic::Security::Instrumentation::AsyncHttp)

data/lib/newrelic_security/instrumentation-security/async-http/prepend.rb

@@ -0,0 +1,16 @@
+module NewRelic::Security
+  module Instrumentation
+    module AsyncHttp
+      module Prepend
+        include NewRelic::Security::Instrumentation::AsyncHttp
+
+        def call(method, url, headers = nil, body = nil)
+          retval = nil
+          event = call_on_enter(method, url, headers, body) { retval = super }
+          call_on_exit(event) { return retval }
+        end
+
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/curb/chain.rb

@@ -0,0 +1,26 @@
+module NewRelic::Security
+  module Instrumentation
+    module Curl
+      module Multi
+        module Chain
+
+          def self.instrument!
+            ::Curl::Multi.class_eval do
+              include NewRelic::Security::Instrumentation::Curl::Multi
+
+              alias_method :perform_without_security, :perform
+    
+              def perform(*args, &block)
+                retval = nil
+                event = perform_on_enter(*args) { retval = perform_without_security(*args, &block) }
+                perform_on_exit(event) { return retval }
+              end
+              
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/curb/instrumentation.rb

@@ -0,0 +1,52 @@
+require_relative 'prepend'
+require_relative 'chain'
+
+module NewRelic::Security
+  module Instrumentation
+    module Curl::Multi
+
+      def perform_on_enter(*args)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        ic_args = []
+        self.requests.each {
+          |key, req|
+          uri = NewRelic::Security::Instrumentation::InstrumentationUtils.parse_uri(req.url)
+          ob = {}
+          if uri
+            ob[:Method]  = nil
+            ob[:scheme]  = uri.scheme
+            ob[:host]    = uri.host
+            ob[:port]    = uri.port
+            ob[:URI]     = uri.to_s
+            ob[:path]    = uri.path
+            ob[:query]   = uri.query
+            ob[:Body]    = req.post_body
+            ob[:Headers] = req.headers
+            ob.each { |_, value| value.dup.force_encoding(ISO_8859_1).encode(UTF_8) if value.is_a?(String) }
+            ic_args.push(ob)
+          end
+        }
+        event = NewRelic::Security::Agent::Control::Collector.collect(HTTP_REQUEST, ic_args)
+        self.requests.each { |key, req| NewRelic::Security::Instrumentation::InstrumentationUtils.add_tracing_data(req.headers, event) } if event
+        event
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+
+      def perform_on_exit(event)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+    end
+  end
+end
+
+NewRelic::Security::Instrumentation::InstrumentationLoader.install_instrumentation(:curb, ::Curl::Multi, ::NewRelic::Security::Instrumentation::Curl::Multi)

data/lib/newrelic_security/instrumentation-security/curb/prepend.rb

@@ -0,0 +1,18 @@
+module NewRelic::Security
+  module Instrumentation
+    module Curl
+      module Multi
+        module Prepend
+          include NewRelic::Security::Instrumentation::Curl::Multi
+
+          def perform(*args, &block)
+            retval = nil
+            event = perform_on_enter(*args) { retval = super }
+            perform_on_exit(event) { return retval }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/dir/chain.rb

@@ -0,0 +1,42 @@
+module NewRelic::Security
+  module Instrumentation
+    module Dir
+      module Chain
+
+        def self.instrument!
+          ::Dir.class_eval do
+            class << self
+              include ::NewRelic::Security::Instrumentation::Dir
+
+              alias_method :mkdir_without_security, :mkdir
+
+              def mkdir(*var)
+                retval = nil
+                event = mkdir_on_enter(*var) { retval = mkdir_without_security(*var) }
+                mkdir_on_exit(event, retval) { return retval }
+              end
+
+              alias_method :rmdir_without_security, :rmdir
+
+              def rmdir(name)
+                retval = nil
+                event = rmdir_on_enter(name) { retval = rmdir_without_security(name) }
+                rmdir_on_exit(event, retval) { return retval }
+              end
+              
+              alias_method :unlink_without_security, :unlink
+
+              def unlink(name)
+                retval = nil
+                event = unlink_on_enter(name) { retval = unlink_without_security(name) }
+                unlink_on_exit(event, retval) { return retval }
+              end
+
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/dir/instrumentation.rb

@@ -0,0 +1,102 @@
+require_relative 'prepend'
+require_relative 'chain'
+
+module NewRelic::Security
+  module Instrumentation
+    module Dir
+
+      def mkdir_on_enter(*var)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        fname = var[0]
+        abs_path = ::File.expand_path(fname)
+        if NewRelic::Security::Instrumentation::InstrumentationUtils.notify_app_integrity_open?(fname, abs_path, WRITE)
+          event = NewRelic::Security::Agent::Control::Collector.collect(FILE_INTEGRITY, [fname], WRITE)
+        else
+          if NewRelic::Security::Instrumentation::InstrumentationUtils.read_filter?(fname, abs_path)
+            NewRelic::Security::Agent.logger.debug "Filtered because File name exist in filtered list #{self.class}.#{__method__} Args:: #{fname}"
+          else
+            event = NewRelic::Security::Agent::Control::Collector.collect(FILE_OPERATION, [fname], WRITE)
+          end 
+        end
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+      
+      def mkdir_on_exit(event, retval)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event) if retval.is_a?(Integer)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+      def rmdir_on_enter(name)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        fname = name
+        abs_path = ::File.expand_path(fname)
+        if NewRelic::Security::Instrumentation::InstrumentationUtils.notify_app_integrity_delete?([fname])
+          event = NewRelic::Security::Agent::Control::Collector.collect(FILE_INTEGRITY, [fname], DELETE)
+        else
+          if NewRelic::Security::Instrumentation::InstrumentationUtils.read_filter?(fname, abs_path)
+            NewRelic::Security::Agent.logger.debug "Filtered because File name exist in filtered list #{self.class}.#{__method__} Args:: #{fname}"
+          else
+            event = NewRelic::Security::Agent::Control::Collector.collect(FILE_OPERATION, [fname], DELETE)
+          end 
+        end
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+      
+      def rmdir_on_exit(event, retval)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event) if retval.is_a?(Integer)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+
+      def unlink_on_enter(*var)
+        event = nil
+        NewRelic::Security::Agent.logger.debug "OnEnter : #{self.class}.#{__method__}"
+        fname = var[0]
+        abs_path = ::File.expand_path(fname)
+        if NewRelic::Security::Instrumentation::InstrumentationUtils.notify_app_integrity_delete?([fname])
+          event = NewRelic::Security::Agent::Control::Collector.collect(FILE_INTEGRITY, [fname], DELETE)
+        else
+          if NewRelic::Security::Instrumentation::InstrumentationUtils.read_filter?(fname, abs_path)
+            NewRelic::Security::Agent.logger.debug "Filtered because File name exist in filtered list #{self.class}.#{__method__} Args:: #{fname}"
+          else
+            event = NewRelic::Security::Agent::Control::Collector.collect(FILE_OPERATION, [fname], DELETE)
+          end 
+        end
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+        return event
+      end
+      
+      def unlink_on_exit(event, retval)
+        NewRelic::Security::Agent.logger.debug "OnExit :  #{self.class}.#{__method__}"
+        NewRelic::Security::Agent::Utils.create_exit_event(event) if retval.is_a?(Integer)
+      rescue => exception
+        NewRelic::Security::Agent.logger.error "Exception in hook in #{self.class}.#{__method__}, #{exception.inspect}, #{exception.backtrace}"
+      ensure
+        yield
+      end
+      
+    end
+  end
+end
+
+NewRelic::Security::Instrumentation::InstrumentationLoader.install_instrumentation(:dir, ::Dir.singleton_class, ::NewRelic::Security::Instrumentation::Dir)

data/lib/newrelic_security/instrumentation-security/dir/prepend.rb

@@ -0,0 +1,28 @@
+module NewRelic::Security
+  module Instrumentation
+    module Dir
+      module Prepend
+        include ::NewRelic::Security::Instrumentation::Dir
+
+        def mkdir(*var)
+          retval = nil
+          event = mkdir_on_enter(*var) { retval = super }
+          mkdir_on_exit(event, retval) { return retval }
+        end
+
+        def rmdir(name)
+          retval = nil
+          event = rmdir_on_enter(name) { retval = super }
+          rmdir_on_exit(event, retval) { return retval }
+        end
+
+        def unlink(name)
+          retval = nil
+          event = unlink_on_enter(name) { retval = super }
+          unlink_on_exit(event, retval) { return retval }
+        end
+
+      end
+    end
+  end
+end

data/lib/newrelic_security/instrumentation-security/ethon/chain.rb

@@ -0,0 +1,53 @@
+module NewRelic::Security
+  module Instrumentation
+    module Ethon
+      module Easy
+        module Chain
+          def self.instrument!
+            ::Ethon::Easy.class_eval do
+              include NewRelic::Security::Instrumentation::Ethon::Easy
+
+              alias_method :fabricate_without_security, :fabricate
+    
+              def fabricate(url, action_name, options)
+                fabricate_on_enter(url, action_name, options) { return fabricate_without_security(url, action_name, options) }
+              end
+
+              alias_method(:headers_equals_without_security, :headers=)
+    
+              def headers=(headers)
+                headers_equals_on_enter(headers) { return headers_equals_without_security(headers) }
+              end
+
+              alias_method :perform_without_security, :perform
+    
+              def perform(*args)
+                retval = nil
+                event = perform_on_enter(*args) { retval = perform_without_security(*args) }
+                perform_on_exit(event) { return retval }
+              end
+            end
+          end
+        end
+      end
+
+      module Multi
+        module Chain
+          def self.instrument!
+            ::Ethon::Multi.class_eval do
+              include NewRelic::Security::Instrumentation::Ethon::Multi
+
+              alias_method :perform_without_security, :perform
+    
+              def perform(*args)
+                retval = nil
+                event = perform_on_enter(*args) { retval = perform_without_security(*args) }
+                perform_on_exit(event) { return retval }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end