contrast-agent 6.6.0 → 6.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9901918f58625ea7f9366f73110afcdd5f05e119261ba9a08f24f36903fe897
-  data.tar.gz: c618ebc74b006529e2317cd62ba59fabbba9d0c8fbf24c7988dfd98ec627b04e
+  metadata.gz: 0ba6de8e82da25931f2fd6d90f515451c33521c02c0fd00e0120ea05701bdc23
+  data.tar.gz: 953297f4f0908bcdcf4791f91869dcf69312f44fe05e743e1e681ce9d3aa9b6f
 SHA512:
-  metadata.gz: d2f584a6658ab0e316b41021575888d9ecc1eaacf79d971492fd2e6317609bfd0cb3a762a64d620b08fc18c76e2434d05cc3d82f8d587c86cdae5116df6cae61
-  data.tar.gz: df8f941fe730188be0bc3b69bd9a9d6d60f9695be8ee8e8eb0b6e35ab1207d97debba28220ff796bec702ad3b158f53f00f87a58f1c14939092ed843bef66715
+  metadata.gz: f7e96583d53e23400fd53fd24aed86c728e0d9b8d79a17179cc1bb96a50ad002e047805b10cea0eaa362802c494ff0b45463a16b53a008e9921723cd9e6e43f9
+  data.tar.gz: f3c7c2a5b575233f4f8d3e9058b281352133625ab42d50b3c6590c7178728ceda8c494953890a0d50e1413ad5f1e50c04595cc035d5f3ed247611f3a1401095e

data/lib/contrast/agent/assess/policy/source_method.rb

@@ -38,19 +38,20 @@ module Contrast
             # @param ret [Object] the Return of the invoked method
             # @param args [Array<Object>] the Arguments with which the method was invoked
             def apply_source method_policy, object, ret, args
-              return unless analyze?(method_policy, object, ret, args)
-              return if event_limit?(method_policy)
-              return unless (source_node = method_policy.source_node)
+              logger.trace_with_time('Elapsed time for Contrast::Agent::Assess::Policy::SourceMethod#apply_source') do
+                return unless analyze?(method_policy, object, ret, args)
+                return if event_limit?(method_policy)
+                return unless (source_node = method_policy.source_node)
 
-              # used to hold the object and ret
-              source_data = Contrast::Agent::Assess::Events::EventData.new(nil, nil, object, ret, nil)
+                # used to hold the object and ret
+                source_data = Contrast::Agent::Assess::Events::EventData.new(nil, nil, object, ret, nil)
 
-              return unless (target = determine_target(source_node, source_data, args))
-              return if target.cs__frozen? && !Contrast::Agent::Assess::Tracker.trackable?(target)
+                return unless (target = determine_target(source_node, source_data, args))
+                return if target.cs__frozen? && !Contrast::Agent::Assess::Tracker.trackable?(target)
 
-              process_source(source_node, target, source_data, source_node.type, nil, *args)
+                process_source(source_node, target, source_data, source_node.type, nil, *args)
+              end
             end
-            Contrast::Components::Logger.add_trace_log_timing_for(SourceMethod, :apply_source)
 
             private
 

data/lib/contrast/agent/middleware.rb

@@ -61,13 +61,14 @@ module Contrast
       # @return [Array,Rack::Response] the Response of this and subsequent Middlewares to be passed back to the user up
       #   the Rack framework.
       def call env
-        return app.call(env) unless ::Contrast::AGENT.enabled?
+        logger.trace_with_time('Elapsed time for Contrast::Agent::Middleware#call') do
+          return app.call(env) unless ::Contrast::AGENT.enabled?
 
-        Contrast::Agent.heapdump_util.start_thread!
-        handle_first_request
-        call_with_agent(env)
+          Contrast::Agent.heapdump_util.start_thread!
+          handle_first_request
+          call_with_agent(env)
+        end
       end
-      ::Contrast::Components::Logger.add_trace_log_timing_for(::Contrast::Agent::Middleware, :call)
 
       private
 

data/lib/contrast/agent/version.rb

@@ -3,6 +3,6 @@
 
 module Contrast
   module Agent
-    VERSION = '6.6.0'
+    VERSION = '6.6.1'
   end
 end

data/lib/contrast/components/logger.rb

@@ -16,16 +16,6 @@ module Contrast
         def cef_logger
           @_cef_logger ||= Contrast::Logger::CEFLog.instance.tap(&:build_logger)
         end
-
-        def add_trace_perf_logging_for sym, custom_message = nil
-          logger.add_trace_perf_logging(self, sym, custom_message)
-        end
-      end
-
-      class << self
-        def add_trace_log_timing_for clazz, method_name, custom_message = nil
-          Contrast::Logger::Log.instance.add_method_to_trace_timing(clazz, method_name, custom_message)
-        end
       end
 
       # So This class here follows the update for the configuration

data/lib/contrast/logger/application.rb

@@ -12,7 +12,8 @@ module Contrast
         return unless info?
 
         info('Process environment information', p_id: Process.pid, pp_id: Process.ppid,
-                                                agent_version: Contrast::Agent::VERSION)
+                                                agent_version: Contrast::Agent::VERSION,
+                                                ruby_version: RUBY_VERSION)
         ENV.each do |env_key, env_value|
           env_key = env_key.to_s
           next unless ENV_KEYS.include?(env_key) ||

data/lib/contrast/logger/log.rb

@@ -13,72 +13,6 @@ require 'contrast/logger/time'
 require 'contrast/components/config'
 require 'contrast/utils/log_utils'
 
-module Contrast
-  # This module allows us to dynamically weave timing into our code, so that only when the time is actually needed do
-  # we pay the penalty for that timing block
-  module TraceTiming
-    def methods_to_time
-      @_methods_to_time ||= []
-    end
-
-    # Store info about methods for later patching.
-    METHOD_INFO = Struct.new(:clazz, :method_name, :custom_msg, :aliased)
-
-    # Add a method to the list of methods to be trace timed if logger set to TRACE. Enables trace timing after if
-    # logger set to TRACE.
-    #
-    # @param: clazz [Class] the class of the method to time.
-    # @param: method [Symbol] the method to time.
-    # @param: method [String] optional custom logging message.
-    def add_method_to_trace_timing clazz, method, msg = nil
-      methods_to_time.append(METHOD_INFO.new(clazz, method, msg, false))
-      enable_trace_timing if logger.level == ::Ougai::Logging::TRACE
-    end
-
-    # Add a method to the list of methods to be trace timed if logger set to TRACE. Enables trace timing after if
-    # logger set to TRACE.
-    #
-    # @param: meth_spec [METHOD_INFO] specs about the method to be timed.
-    # @param: class_method [Boolean] whether this is or isn't a class/module method.
-    def trace_time_class_method meth_spec, class_method # rubocop:disable Metrics/AbcSize
-      untimed_func_symbol = "untimed_#{ meth_spec.method_name }".to_sym
-      send_to = class_method ? meth_spec.clazz.cs__singleton_class : meth_spec.clazz
-      meth_spec.clazz.class_eval do
-        include(Contrast::Components::Logger::InstanceMethods)
-        extend(Contrast::Components::Logger::InstanceMethods)
-
-        send_to.send(:alias_method, untimed_func_symbol, meth_spec.method_name)
-        meth_spec.aliased = true
-
-        log_message = "Elapsed time for #{ meth_spec.method_name }."
-        log_message = meth_spec.custom_message if meth_spec.custom_msg
-
-        send_to.send(:define_method, meth_spec.method_name) do |*args, **kwargs, &block| # rubocop:disable Performance/Kernel/DefineMethod
-          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          rv = if kwargs.empty?
-                 send(untimed_func_symbol, *args, &block)
-               else
-                 send(untimed_func_symbol, *args, **kwargs, &block)
-               end
-          delta = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-          logger.trace(log_message, elapsed: delta * 1000)
-          rv
-        end
-      end
-    end
-
-    # Enable trace timing of methods specified in @_methods_to_time via aliasing.
-    def enable_trace_timing
-      methods_to_time.each do |meth_spec|
-        next if meth_spec.aliased
-
-        is_class_method = meth_spec.clazz.singleton_methods(false).include?(meth_spec.method_name)
-        trace_time_class_method(meth_spec, is_class_method)
-      end
-    end
-  end
-end
-
 module Contrast
   # Used as a wrapper around our logging. The module option specifically adds in a new method for error that raises the
   # logged exception, used in testing so that we can see if anything unexpected happens without it being swallowed
@@ -105,7 +39,6 @@ module Contrast
     # level based on updates to TeamServer.
     class Log
       include Singleton
-      include ::Contrast::TraceTiming
       include Contrast::Utils::LogUtils
 
       attr_reader :previous_path, :previous_level
@@ -132,8 +65,6 @@ module Contrast
         @previous_path  = current_path
         @previous_level = current_level_const
 
-        enable_trace_timing if current_level_const == ::Ougai::Logging::TRACE
-
         progname = Contrast::CONFIG.root.agent.logger.progname
         @_logger = build(path: current_path, level_const: current_level_const, progname: progname)
         # If we're logging to a new path, then let's start it w/ our helpful

data/lib/contrast/logger/time.rb

@@ -8,31 +8,38 @@ module Contrast
     module Time
       # Log the message at the given level.
       #
-      # @param level [String] the name of the method to use. Should be one of
-      #   trace, debug, info, warn, error
+      # @param level [String] the name of the method to use. Should be one of trace, debug, info, warn, error
       # @param message [String] the message to log
       def with_level level, message
         send(level.to_sym, message)
       end
 
-      # Log, at the debug level, the action with a message including the time
-      # it took for the wrapped function to complete.
+      # Log, at the debug level, the action with a message including the time it took for the wrapped function to
+      # complete. If not logging to debug, simply yield the given block.
       #
-      # @param msgs [Array<Object>] the arguments to pass to the logger.
-      #   msgs[0] will be modified to include the elapsed time.
+      # @param msgs [Array<Object>] the arguments to pass to the logger. msgs[0] will be modified to include the elapsed
+      #   time.
       # @param block [Block, Proc] the block to execute
       def debug_with_time *msgs, &block
-        log_with_time(:debug, *msgs, &block)
+        if debug?
+          log_with_time(:debug, *msgs, &block)
+        elsif block
+          yield
+        end
       end
 
-      # Log, at the trace level, the action with a message including the time
-      # it took for the wrapped function to complete.
+      # Log, at the trace level, the action with a message including the time it took for the wrapped function to
+      # complete. If not logging to debug, simply yield the given block.
       #
-      # @param msgs [Array<Object>] the arguments to pass to the logger.
-      #   msgs[0] will be modified to include the elapsed time.
+      # @param msgs [Array<Object>] the arguments to pass to the logger. msgs[0] will be modified to include the elapsed
+      #   time.
       # @param block [Block, Proc] the block to execute
       def trace_with_time *msgs, &block
-        log_with_time(:trace, *msgs, &block)
+        if trace?
+          log_with_time(:trace, *msgs, &block)
+        elsif block
+          yield
+        end
       end
 
       private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contrast-agent
 version: !ruby/object:Gem::Version
-  version: 6.6.0
+  version: 6.6.1
 platform: ruby
 authors:
 - galen.palmer@contrastsecurity.com