contrast-agent 7.1.0 → 7.3.0

data/lib/contrast/agent/reporting/reporting_utilities/response_handler_utils.rb

@@ -54,6 +54,16 @@ module Contrast
           @_last_application_modified
         end
 
+        # Cease reporting about this application
+        #
+        # @param message [String] Message to log
+        # @param info_hash [Hash] information about the context to log.
+        def stop_reporting message, info_hash
+          Contrast::Agent.reporter&.stop!
+          log_error_msg(message, info_hash)
+          ::Contrast::AGENT.disable!
+        end
+
         private
 
         # check if response code is valid before analyze it
@@ -127,7 +137,7 @@ module Contrast
           # log, suspend, disable:
           if mode == @_mode.running
             log_error_msg(message,
-                          response: response.__id__,
+                          response_id: response.__id__,
                           request: Contrast::Agent::REQUEST_TRACKER.current&.request&.type,
                           error_message: error_message || 'none',
                           auth_error: auth_error || 'none')
@@ -176,16 +186,6 @@ module Contrast
           end
         end
 
-        # Cease reporting about this application
-        #
-        # @param message [String] Message to log
-        # @param info_hash [Hash] information about the context to log.
-        def stop_reporting message, info_hash
-          Contrast::Agent.reporter&.stop!
-          log_error_msg(message, info_hash)
-          ::Contrast::AGENT.disable!
-        end
-
         # Applies the settings from the TS response
         #
         # @param response [Contrast::Agent::Reporting::Response]

data/lib/contrast/agent/request/request.rb

@@ -10,6 +10,7 @@ require 'contrast/utils/hash_digest'
 require 'contrast/components/logger'
 require 'contrast/components/scope'
 require 'contrast/utils/request_utils'
+require 'contrast/utils/duck_utils'
 
 module Contrast
   module Agent
@@ -24,12 +25,7 @@ module Contrast
 
       extend Forwardable
 
-      INNER_REST_TOKEN = %r{/\d+/}.cs__freeze
-      LAST_REST_TOKEN = %r{/\d+$}.cs__freeze
-      INNER_NUMBER_MARKER = '/{n}/'
-      LAST_NUMBER_MARKER = '/{n}'
-      STATIC_SUFFIXES = /\.(?:js|css|jpeg|jpg|gif|png|ico|woff|svg|pdf|eot|ttf|jar)$/i.cs__freeze
-      MEDIA_TYPE_MARKERS = %w[image/ text/css text/javascript].cs__freeze
+      EMPTY_PATH = '/'
 
       # @return [Rack::Request] The passed to the Agent RackRequest to be wrapped.
       attr_reader :rack_request
@@ -75,12 +71,31 @@ module Contrast
       def normalized_uri
         @_normalized_uri ||= begin
           path = rack_request.path_info || rack_request.path.to_s
-          path = '/' if path.empty?
-
-          uri = path.split(Contrast::Utils::ObjectShare::SEMICOLON)[0]    # remove ;jsessionid
-          uri = uri.split(Contrast::Utils::ObjectShare::QUESTION_MARK)[0] # remove ?query_string=
-          uri.gsub(INNER_REST_TOKEN, INNER_NUMBER_MARKER)                 # replace interior tokens
-          uri.gsub(LAST_REST_TOKEN, LAST_NUMBER_MARKER)                   # replace last token
+          path = EMPTY_PATH if Contrast::Utils::DuckUtils.empty_duck?(path)
+
+          # /foo/bar;jsessionid=123 => /foo/bar
+          uri = path.split(Contrast::Utils::ObjectShare::SEMICOLON)[0]
+          # /foo/bar?query_string=123 => /foo/bar
+          uri = uri.split(Contrast::Utils::ObjectShare::QUESTION_MARK)[0]
+
+          # Replace with tokens:
+          # NUM_ => '/{n}/'
+          # ID_ =>  '{ID}'
+          #
+          # replace UUIDs: /123e4567-e89b-42d3-a456-556642440000/ => /{ID}/
+          uri.gsub!(UUID_PATTERN, ID_)
+          # replace hash patterns: /6f1ed002ab5595859014ebf0951522d9/ => /{ID}/
+          uri.gsub!(HASH_PATTERN, ID_)
+          # replace windows SID: /S-1-5-21-1843332746-572796286-2118856591-1000/ => /{ID}/
+          uri.gsub!(WIN_PATTERN, ID_)
+          # replace interior number tokens: /123/ => /{n}/
+          uri.gsub!(NUM_PATTERN, NUM_)
+          # replace last number tokens: /123 => /{n}
+          uri.gsub!(END_PATTERN, NUM_[0..-2])
+          uri
+        rescue StandardError => e
+          logger.error('error normalizing uri', error: e, backtrace: e.backtrace)
+          EMPTY_PATH
         end
       end
 

data/lib/contrast/agent/telemetry/base.rb

@@ -8,6 +8,7 @@ require 'contrast/agent/thread/worker_thread'
 require 'contrast/agent/telemetry/telemetry'
 require 'contrast/agent/telemetry/exception'
 require 'contrast/utils/job_servers_running'
+require 'contrast/agent/reporting/client/interface'
 
 module Contrast
   module Agent
@@ -96,11 +97,7 @@ module Contrast
         end
 
         def client
-          @_client ||= Contrast::Agent::Telemetry::Client.new
-        end
-
-        def connection
-          @_connection ||= client.initialize_connection(URL)
+          @_client ||= Contrast::Agent::Reporting::Telemetry::Interface.new
         end
 
         def attempt_to_start?
@@ -146,10 +143,8 @@ module Contrast
           super
           delete_queue!
           Contrast::TELEMETRY_EXCEPTIONS&.clear
-        end
-
-        def request_with_response event
-          client.handle_response(client.send_request(event, connection))
+          Contrast::TELEMETRY_IA_CACHE&.clear
+          Contrast::TELEMETRY_BASE64_HASH&.clear
         end
 
         private
@@ -158,6 +153,18 @@ module Contrast
           @_queue ||= Queue.new
         end
 
+        # Starts sending Telemetry messages.
+        def process_event event
+          logger.debug('[Telemetry] This is the current processed event', event)
+          if (sleep_time = client.request_with_response(event))
+            return sleep(sleep_time)
+          end
+
+          logger.debug('[Telemetry] Retrying to process event', event)
+          retry_sleep_time = client.request_with_response(event)
+          sleep(retry_sleep_time) unless retry_sleep_time.nil?
+        end
+
         # It is recommended that implementations send a single payload of general metrics every 3 hours, starting from
         # implementation startup. This returns a thread configured to do so.
         #
@@ -165,22 +172,15 @@ module Contrast
         def create_thread
           Contrast::Agent::Thread.new do
             loop do
-              next unless client && connection
+              next unless client.connected?
               break unless attempt_to_start?
 
               # Start pushing exceptions to queue for reporting.
-              Contrast::TELEMETRY_EXCEPTIONS.each_value { |value| queue << value }
-              Contrast::TELEMETRY_EXCEPTIONS.clear
+              gather_telemetry_events
               until queue.empty?
                 event = queue.pop
                 begin
-                  logger.debug('[Telemetry] This is the current processed event', event)
-                  if (sleep_time = request_with_response(event))
-                    sleep(sleep_time)
-                    logger.debug('[Telemetry] Retrying to process event', event)
-                    retry_sleep_time = request_with_response(event)
-                    sleep(retry_sleep_time) unless retry_sleep_time.nil?
-                  end
+                  process_event(event)
                 rescue StandardError => e
                   logger.error('[Telemetry] Could not send message to service from telemetry queue.', e)
                   stop!
@@ -190,6 +190,31 @@ module Contrast
             end
           end
         end
+
+        # Fills the queue with events that were not able to be sent previously.
+        def gather_telemetry_events
+          gather_exceptions
+          gather_encoding_events
+          gather_ia_cache_events
+        end
+
+        # Retrieves the exceptions that were accumulated.
+        def gather_exceptions
+          Contrast::TELEMETRY_EXCEPTIONS&.each_value { |value| queue << value }
+          Contrast::TELEMETRY_EXCEPTIONS&.clear
+        end
+
+        # Retrieves the base64 encoded events that were accumulated.
+        def gather_encoding_events
+          Contrast::TELEMETRY_BASE64_HASH&.each_value { |values| values.each { |event| queue << event } }
+          Contrast::TELEMETRY_BASE64_HASH&.clear
+        end
+
+        # Retrieves the IA cache events that were accumulated.
+        def gather_ia_cache_events
+          Contrast::TELEMETRY_IA_CACHE&.each_value { |values| values.each { |event| queue << event } }
+          Contrast::TELEMETRY_IA_CACHE&.clear
+        end
       end
     end
   end

data/lib/contrast/agent/telemetry/base64_hash.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/telemetry/input_analysis_encoding_event'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This hash will store the telemetry data for the Protect InputAnalysis cache.
+      class Base64Hash < Hash
+        include Contrast::Components::Logger::InstanceMethods
+        # Set per request:
+        HASH_SIZE_LIMIT = 100
+
+        # Wrapper to set a value in this Telemetry::Hash only if the provided value is of the data_type for this
+        # Telemetry::CacheHash or the hash has not reached its limit for unique keys.
+        # Saves Array of reportable events.
+        #
+        # @param key [Object] the key to which to associate the value
+        # @param events [array<Object>]
+        # @return [Object, nil] echo back out the value as the Hash#[]= method does, or nil if not of the expected
+        #   data_type
+        def []= key, events
+          # If telemetry is not running, do not add more as we want to avoid a memory leak.
+          return unless Contrast::Agent.telemetry_queue&.running?
+          # If the Hash is full, do not add more as we want to avoid consuming all application resources.
+          return if at_limit?
+          # If the given value is of unexpected type, do not add it to avoid issues later where type is assumed.
+          return unless valid_event?(events)
+
+          super(key, events)
+        end
+
+        # Determine if hash has reached exception event limit.
+        #
+        # @return [Boolean]
+        def at_limit?
+          unless length < HASH_SIZE_LIMIT
+            logger.debug("[Telemetry] Number of IA base64 events exceeds limit of #{ HASH_SIZE_LIMIT }")
+            return true
+          end
+          false
+        end
+
+        private
+
+        # Checks to see if the given object is a valid event.
+        # @param events [Contrast::Agent::Telemetry::InputAnalysisEncodingEvent]
+        def valid_event? events
+          events&.all?(Contrast::Agent::Telemetry::InputAnalysisEncodingEvent)
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/cache_hash.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/telemetry/input_analysis_cache_event'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This hash will store the telemetry data for the Protect InputAnalysis cache.
+      class CacheHash < Hash
+        include Contrast::Components::Logger::InstanceMethods
+        # Set per request:
+        HASH_SIZE_LIMIT = 100
+
+        # Wrapper to set a value in this Telemetry::Hash only if the provided value is of the data_type for this
+        # Telemetry::CacheHash or the hash has not reached its limit for unique keys.
+        # Saves Array of reportable events.
+        #
+        # @param key [Object] the key to which to associate the value
+        # @param events [array<Object>]
+        # @return [Object, nil] echo back out the value as the Hash#[]= method does, or nil if not of the expected
+        #   data_type
+        def []= key, events
+          # If telemetry is not running, do not add more as we want to avoid a memory leak.
+          return unless Contrast::Agent.telemetry_queue&.running?
+          # If the Hash is full, do not add more as we want to avoid consuming all application resources.
+          return if at_limit?
+          # If the given value is of unexpected type, do not add it to avoid issues later where type is assumed.
+          return unless valid_event?(events)
+
+          super(key, events)
+        end
+
+        # Determine if hash has reached exception event limit.
+        #
+        # @return [Boolean]
+        def at_limit?
+          unless length < HASH_SIZE_LIMIT
+            logger.debug("[Telemetry] Number of IA cache events exceeds limit of #{ HASH_SIZE_LIMIT }")
+            return true
+          end
+          false
+        end
+
+        private
+
+        # Checks to see if the given object is a valid event.
+        # @param event [Contrast::Agent::Telemetry::InputAnalysisCacheEvent]
+        def valid_event? events
+          events&.all?(Contrast::Agent::Telemetry::InputAnalysisCacheEvent)
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/client.rb

@@ -65,6 +65,7 @@ module Contrast
                         else
                           60
                         end
+          logger.debug('[Telemetry] received response.', response_code: status_code)
           ready_after if status_code == 429
         end
 
@@ -76,6 +77,8 @@ module Contrast
           return true if event.cs__is_a?(Contrast::Agent::Telemetry::Event)
           return true if event.cs__is_a?(Contrast::Agent::Telemetry::StartupMetricsEvent)
           return true if event.cs__is_a?(Contrast::Agent::Telemetry::Exception::Event)
+          return true if event.cs__is_a?(Contrast::Agent::Telemetry::InputAnalysisCacheEvent)
+          return true if event.cs__is_a?(Contrast::Agent::Telemetry::InputAnalysisEncodingEvent)
 
           false
         end
@@ -93,12 +96,17 @@ module Contrast
           "#{ Contrast::Agent::Telemetry::Base::URL }#{ endpoint }#{ path }"
         end
 
-        # Helper Method to get json representation of Telemetry Event data, handles error on to_json
+        # Helper Method to get json representation of Telemetry Event data, handles error on to_json.
+        # Generating bodies for exceptions and startup metrics is different.
         #
         # @param event [Contrast::Agent::Telemetry::Event, Array<Contrast::Agent::Telemetry::Exception::Event>]
         # @return [String] - JSON
         def get_event_json event
-          Array(event.to_controlled_hash).to_json
+          if event.cs__is_a?(Contrast::Agent::Telemetry::Exception::Event)
+            return Array(event.to_controlled_hash).to_json
+          end
+
+          [event.to_controlled_hash].to_json
         rescue Exception => e # rubocop:disable Lint/RescueException
           logger.error('[Telemetry] Unable to convert TelemetryEvent to JSON string', e, hsh)
           raise(e)

data/lib/contrast/agent/telemetry/exception/obfuscate.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/duck_utils'
+require 'contrast/utils/object_share'
+
+module Contrast
+  module Agent
+    module Telemetry
+      module Exception
+        # Obfuscate sensitive user data before building exception.
+        module Obfuscate
+          CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'.cs__freeze
+          # This will generate different chars for each agent startup but will be constant
+          # for current run and will make identical obfuscation to be compared if given type
+          # is the same.
+          CYPHER = CHARS.chars.shuffle.join.cs__freeze
+          VERSION_MATCH = '[^0-9].-'
+
+          # List of known places after witch a user name might appear:
+          KNOWN_DIRS = %w[app application project projects git github users home user].cs__freeze
+
+          class << self
+            # Returns paths for known gems.
+            #
+            # @return [Array<Regexp>] known paths
+            def known_paths
+              @_known_paths ||= KNOWN_DIRS.map do |name|
+                to_regexp(name)
+              end
+            end
+
+            # Obfuscate a type and replace it with random characters.
+            #
+            # @param path [String] the StackFrame type to obfuscate
+            # @return [String] obfuscated type
+            def obfuscate_path path
+              return path if Contrast::Utils::DuckUtils.empty_duck?(path)
+
+              cypher(path)
+            end
+
+            private
+
+            # Transforms string to regexp
+            #
+            # @param string [String]
+            def to_regexp string
+              /#{ string }/
+            end
+
+            # Add cypher to path to make it obscure, but unique enough for
+            # comparisons. Mutates original or duplicate if frozen string.
+            #
+            # @param string [String] string to be transformed.
+            # @return [String]
+            def cypher string
+              cypher = string.cs__frozen? ? string.dup : string
+              dirs = cypher.split(Contrast::Utils::ObjectShare::SLASH)
+              return string unless dirs.cs__is_a?(Array)
+
+              dirs.each_with_index do |name, idx|
+                next if Contrast::Utils::DuckUtils.empty_duck?(name)
+                next unless match_known(known_paths,
+                                        name.tr(VERSION_MATCH, Contrast::Utils::ObjectShare::EMPTY_STRING).downcase)
+
+                obscure(name)
+                # obscure username (next dir in line)
+                obscure(dirs[idx + 1]) if dirs[idx + 1]
+              end
+              cypher = dirs.join(Contrast::Utils::ObjectShare::SLASH)
+              return cypher if cypher
+
+              Contrast::Utils::ObjectShare::EMPTY_STRING
+            rescue StandardError
+              Contrast::Utils::ObjectShare::EMPTY_STRING
+            end
+
+            # @param known [Array<Regexp>] Array of regexp to match against
+            # @param type [String] type to check
+            def match_known known, type
+              known.any? { |regexp| type =~ regexp }
+            end
+
+            # Replaces chars in name.
+            #
+            # @param [string] name
+            # @return [String, nil]
+            def obscure name
+              name.to_s.tr!(CHARS, CYPHER)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/exception.rb

@@ -17,3 +17,4 @@ require 'contrast/agent/telemetry/exception/stack_frame'
 require 'contrast/agent/telemetry/exception/message_exception'
 require 'contrast/agent/telemetry/exception/message'
 require 'contrast/agent/telemetry/exception/event'
+require 'contrast/agent/telemetry/exception/obfuscate'

data/lib/contrast/agent/telemetry/{hash.rb → exception_hash.rb}

@@ -10,7 +10,7 @@ module Contrast
       # This is the Telemetry::Hash, which will store Contrast::Agent::Telemetry::Exception::Event, so we can push
       # freely, without worrying about validating the event before that. Telemetry::Hash has a max size of events,
       # default is 10 events
-      class Hash < Hash
+      class ExceptionHash < Hash
         include Contrast::Components::Logger::InstanceMethods
         HASH_SIZE_LIMIT = 10
 

data/lib/contrast/agent/telemetry/input_analysis_cache_event.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/telemetry/input_analysis_event'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # Event to report all gather information from the Input Analysis Cache statistics, hits and misses.
+      class InputAnalysisCacheEvent < Contrast::Agent::Telemetry::InputAnalysisEvent
+        NAME = 'InputAnalysis cache event'
+        PATH = '/protect_input_analysis_cache'
+
+        private
+
+        # Creates the tags for the event
+        #
+        # @param rule_id [String]
+        # @param match_rates [Contrast::Agent::Protect::Rule::InputClassification::MatchRates]
+        def add_tags rule_id, match_rates
+          super(rule_id, match_rates)
+          @tags['score_level'] = match_rates&.score_level.dup&.to_s || NOT_APPLICABLE
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/input_analysis_encoding_event.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/telemetry/input_analysis_event'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # Event to report all gather information from the Input Analysis Cache statistics, hits and misses.
+      class InputAnalysisEncodingEvent < Contrast::Agent::Telemetry::InputAnalysisEvent
+        NAME = 'InputAnalysis encoding event'
+        PATH = '/protect_input_analysis_encoding'
+
+        private
+
+        # Creates the tags for the event
+        #
+        # @param _rule_id [String]
+        # @param encode_rates [Contrast::Agent::Protect::Rule::InputClassification::EncodingRates]
+        def add_tags _rule_id, encode_rates
+          super(nil, encode_rates)
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/input_analysis_event.rb

@@ -0,0 +1,91 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/metrics_hash'
+require 'contrast/agent/telemetry/metric_event'
+require 'contrast/agent/version'
+require 'contrast/components/logger'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # Event to report all gather information from the Input Analysis metrics.
+      class InputAnalysisEvent < Contrast::Agent::Telemetry::MetricEvent
+        include Contrast::Components::Logger::InstanceMethods
+        NOT_APPLICABLE = 'n/a'
+
+        attr_reader :fields
+
+        # Override the name for any derived classes
+        NAME = 'InputAnalysis event'
+        # Override the path for any derived classes
+        PATH = '/protect_input_analysis'
+
+        # @param rule_id [String] the rule name.
+        # @param rates [Contrast::Agent::Protect::Rule::InputClassification::Rates] base class for all rates.
+        def initialize rule_id, rates
+          super()
+          @fields = MetricsHash.new(Integer)
+          add_tags(rule_id, rates)
+          generate_fields(rates)
+        end
+
+        # Returns the name of the event.
+        #
+        # @return [String]
+        def name
+          cs__class::NAME
+        end
+
+        # Returns the path to report the event.
+        #
+        # @return [String]
+        def path
+          cs__class::PATH
+        end
+
+        # Override the empty check for any derived classes if needed.
+        def empty?
+          super && Contrast::Utils::DuckUtils.empty_duck?(@tags)
+        end
+
+        private
+
+        # Creates the tags for the event. Overrides the base class to add the rule_id and match_rate.
+        #
+        # @param rule_id [String, nil]
+        # @param rates [Contrast::Agent::Protect::Rule::InputClassification::Rates]
+        def add_tags rule_id, rates
+          return if Contrast::Utils::DuckUtils.empty_duck?(rates)
+          return unless rates.cs__is_a?(Contrast::Agent::Protect::Rule::InputClassification::Rates)
+
+          @tags['event_type'] = name # rubocop:disable Security/Module/Name
+          @tags['test_environment'] = ENV['CONTRAST_AGENT_TELEMETRY_TEST'] == '1' ? 'true' : 'false'
+          @tags['rule_id'] = rule_id if rule_id
+          @tags['input_type'] = rates&.input_type.dup&.to_s || NOT_APPLICABLE
+          add_system_tags
+        end
+
+        # Creates the fields for the event.
+        # Override if needed.
+        #
+        # @param rates [Contrast::Agent::Protect::Rule::InputClassification::Rates] base class for all rates.
+        def generate_fields rates
+          return if Contrast::Utils::DuckUtils.empty_duck?(rates)
+          return unless rates.cs__is_a?(Contrast::Agent::Protect::Rule::InputClassification::Rates)
+
+          rates.to_fields.each { |field, value| @fields[field] = value.dup }
+        end
+
+        # Adds the system tags to the event.
+        def add_system_tags
+          @tags['agent_version'] = VERSION
+          @tags['ruby_version'] = RUBY_VERSION
+          @tags['os_type'] = sys_info['os_type'] == 'Darwin' ? 'MacOS' : 'Linux'
+          @tags['os_arch'] = sys_info['os_arch']
+          @tags['os_version'] = sys_info['os_version']
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/telemetry/metric_event.rb

@@ -3,6 +3,8 @@
 
 require 'contrast/utils/metrics_hash'
 require 'contrast/agent/telemetry/event'
+require 'contrast/utils/duck_utils'
+require 'contrast/utils/os'
 
 module Contrast
   module Agent
@@ -10,6 +12,7 @@ module Contrast
       # This class will hold the basic information for a Telemetry Event
       class MetricEvent < Contrast::Agent::Telemetry::Event
         include Contrast::Utils
+        include Contrast::Utils::OS
 
         attr_reader :fields
 
@@ -19,6 +22,15 @@ module Contrast
           @fields['_filler'] = 0
         end
 
+        def sys_info
+          @sys_info ||= get_system_information if @sys_info.nil?
+          @sys_info
+        end
+
+        def empty?
+          Contrast::Utils::DuckUtils.empty_duck?(@fields)
+        end
+
         def to_controlled_hash **_args
           super.merge!({ fields: @fields })
         end