contrast-agent 6.6.4 → 6.8.0

data/lib/contrast/api/decorators/http_request.rb

@@ -1,137 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/api/dtm.pb'
-require 'contrast/api/decorators/address'
-require 'contrast/components/scope'
-require 'contrast/utils/string_utils'
-require 'contrast/utils/timer'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::HttpRequest} protobuf model
-      # so it can own some of the data massaging required for Request dtm. Only
-      # works as an extension of that class.
-      module HttpRequest
-        OMITTED_BODY = '{{body-omitted-by-contrast}}'
-
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # Append the sender and receiver to self.
-        #
-        # @param request [Contrast::Agent::Request]
-        def append_addresses request
-          self.sender = Contrast::Api::Dtm::Address.build_sender(request)
-          self.receiver = Contrast::Api::Dtm::Address.build_receiver
-        end
-
-        # Append the connection to self.
-        #
-        # @param request [Contrast::Agent::Request]
-        def append_connection request
-          self.protocol = Contrast::Utils::StringUtils.force_utf8(request.scheme)
-          self.version = Contrast::Utils::StringUtils.force_utf8(request.version)
-          self.method = Contrast::Utils::StringUtils.force_utf8(request.request_method)
-          self.raw = Contrast::Utils::StringUtils.force_utf8(request.rack_request.path_info)
-          self.uri = Contrast::Utils::StringUtils.force_utf8(request.rack_request.path_info)
-        end
-
-        # Append the parameters to self, using the preferred
-        # normalized_request_params field.
-        #
-        # @param request [Contrast::Agent::Request]
-        def append_params request
-          request.parameters.each do |k, v|
-            append_pair(normalized_request_params, k, v)
-          end
-        end
-
-        # Append the normalized headers to self, using the preferred
-        # request_headers field.
-        #
-        # @param request [Contrast::Agent::Request]
-        def append_headers request
-          request.headers.each do |k, v|
-            next unless k && v
-            next if v.is_a?(Hash)
-
-            key = Contrast::Utils::StringUtils.force_utf8(k)
-            val = Contrast::Utils::StringUtils.force_utf8(v)
-            request_headers[key] = val
-          end
-
-          request.cookies.each do |k, v|
-            append_pair(normalized_cookies, k, v)
-          end
-        end
-
-        # Append the body to self, using the preferred
-        # request_body_binary field.
-        #
-        # @param request [Contrast::Agent::Request]
-        def append_body request
-          self.document_type = Contrast::Utils::StringUtils.force_utf8(request.document_type)
-
-          self.request_body_binary = if omit_body?(request)
-                                       OMITTED_BODY
-                                     else
-                                       Contrast::Utils::StringUtils.force_utf8(request.body)
-                                     end
-          return if request.file_names.empty?
-
-          request.file_names.each do |name, filename|
-            pair = Contrast::Api::Dtm::SimplePair.new
-            pair.key = Contrast::Utils::StringUtils.force_utf8(name)
-            pair.value = Contrast::Utils::StringUtils.force_utf8(filename)
-            multipart_headers << pair
-          end
-        end
-
-        def omit_body? request
-          return true if ::Contrast::AGENT.omit_body?
-          return false if request.document_type != :NORMAL
-
-          request.media_type&.include?('multipart/form-data')
-        end
-
-        def append_pair map, key, value
-          return unless key && value
-          return if value.is_a?(Hash)
-
-          safe_key = Contrast::Utils::StringUtils.force_utf8(key)
-          map[safe_key] ||= Contrast::Api::Dtm::Pair.new
-          map[safe_key].key = safe_key
-          map[safe_key].values << Contrast::Utils::StringUtils.force_utf8(value)
-        end
-
-        # Used to add class methods to the ApplicationUpdate class on inclusion of the decorator
-        module ClassMethods
-          include Contrast::Components::Scope::InstanceMethods
-
-          # Convert our Request into a DTM
-          # @param request [Contrast::Agent::Request]
-          # @return [Contrast::Api::Dtm::HttpRequest]
-          def build request
-            with_contrast_scope do
-              msg = new
-              msg.uuid = Contrast::Utils::StringUtils.force_utf8(__id__)
-              msg.timestamp_ms = Contrast::Utils::Timer.now_ms.to_i
-
-              msg.append_addresses(request)
-              msg.append_connection(request)
-              msg.append_params(request)
-              msg.append_headers(request)
-              msg.append_body(request)
-              msg
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::HttpRequest.include(Contrast::Api::Decorators::HttpRequest)

data/lib/contrast/api/decorators/input_analysis.rb

@@ -1,18 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/utils/string_utils'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Settings::InputAnalysis} protobuf
-      # model so it can own the request which its data is for.
-      module InputAnalysis
-        attr_accessor :request
-      end
-    end
-  end
-end
-
-Contrast::Api::Settings::InputAnalysis.include(Contrast::Api::Decorators::InputAnalysis)

data/lib/contrast/api/decorators/instrumentation_mode.rb

@@ -1,35 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/api/dtm.pb'
-require 'contrast/components/base'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the InstrumentationMode protobuf model to handle reporting Agent process start
-      module InstrumentationMode
-        include Contrast::Components::ComponentBase
-
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # Used to add class methods to the AgentStartup class on inclusion of the decorator
-        module ClassMethods
-          # Return a new DTM with the values from the configuration
-          #
-          # @return [Contrast::Api::Dtm::InstrumentationMode]
-          def build
-            msg = new
-            msg.assess =  ::Contrast::ASSESS.enabled?
-            msg.protect = ::Contrast::PROTECT.enabled?
-            msg
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::InstrumentationMode.include(Contrast::Api::Decorators::InstrumentationMode)

data/lib/contrast/api/decorators/ip_denylist.rb

@@ -1,37 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/api/dtm.pb'
-require 'contrast/utils/string_utils'
-require 'contrast/components/base'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::IpDenylistDetails} protobuf
-      # model so it can own the request which its data is for.
-      module IpDenylistDetails
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # Used to add class methods to the AgentStartup class on inclusion of the decorator
-        module ClassMethods
-          def build
-            new
-          end
-
-          # @param result [Contrast::Api::Dtm::IpDenylistDetails]
-          def to_controlled_hash result
-            {
-                ip: result.ip,
-                uuid: result.uuid
-            }
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::IpDenylistDetails.include(Contrast::Api::Decorators::IpDenylistDetails)

data/lib/contrast/api/decorators/message.rb

@@ -1,71 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/utils/object_share'
-require 'contrast/utils/string_utils'
-require 'contrast/components/logger'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::Message} protobuf model so it
-      # can handle instance data massaging.
-      module Message
-        include Contrast::Components::Logger::InstanceMethods
-
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        def append_event event
-          case event
-          when Contrast::Api::Dtm::AgentStartup
-            self.agent_startup = event
-          when Contrast::Api::Dtm::ApplicationCreate
-            self.application_create = event
-          when Contrast::Api::Dtm::Activity
-            self.activity = event
-          when Contrast::Api::Dtm::HttpRequest
-            self.prefilter = event
-          when Contrast::Api::Dtm::HttpResponse
-            self.postfilter = event
-          when Contrast::Api::Dtm::Poll
-            self.poll = event
-          else
-            logger.error('Unknown event type received. Unsure how to send.', event_type: event.cs__class.cs__name)
-            return
-          end
-          logger.debug('Wrapping event in message',
-                       msg_id: __id__,
-                       p_id: pid,
-                       msg_count: message_count,
-                       event_id: event.__id__,
-                       event_type: event.cs__class.cs__name)
-        end
-
-        # Used to add class methods to the ApplicationUpdate class on inclusion of the decorator
-        module ClassMethods
-          @@message_total = 0 # rubocop:disable Style/ClassVars
-          def message_count
-            @@message_total += 1 # rubocop:disable Style/ClassVars
-          end
-
-          def build event
-            msg = new
-            msg.app_name      = ::Contrast::APP_CONTEXT.name # rubocop:disable Security/Module/Name
-            msg.app_path      = ::Contrast::APP_CONTEXT.path
-            msg.app_language  = Contrast::Utils::ObjectShare::RUBY
-            msg.client_id     = ::Contrast::APP_CONTEXT.client_id
-            msg.message_count = message_count
-            msg.pid           = ::Contrast::APP_CONTEXT.pid
-            msg.ppid          = ::Contrast::APP_CONTEXT.ppid
-            msg.append_event(event)
-            msg
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::Message.include(Contrast::Api::Decorators::Message)

data/lib/contrast/api/decorators/rasp_rule_sample.rb

@@ -1,58 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::RaspRuleSample} protobuf
-      # model.
-      module RaspRuleSample
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # Used to add class methods to RaspRuleSample
-        module ClassMethods
-          def build context, ia_result
-            sample = new
-            sample.timestamp_ms = context.timer.start_ms
-            sample.user_input = Contrast::Api::Dtm::UserInput.build_from_ia_result(ia_result)
-            sample.user_input.document_type = Contrast::Utils::StringUtils.force_utf8(context.request.document_type)
-            sample
-          end
-
-          # @param result [Contrast::Api::Dtm::RaspRuleSample]
-          def to_controlled_hash result
-            {
-                timestamp: Time.at(result.timestamp_ms).iso8601,
-                user_input: result.user_input,
-                brute_force: result.brute_force,
-                bot_blocker: result.bot_blocker,
-                cmdi: result.cmdi,
-                csrf: result.csrf,
-                cve: result.cve,
-                untrusted_deserialization: result.untrusted_deserialization,
-                el_injection: result.el_injection,
-                mark_of_the_beast: result.mark_of_the_beast,
-                padding_oracle: result.padding_oracle,
-                path_traversal: result.path_traversal,
-                re_dos: result.re_dos,
-                sqli: result.sqli,
-                ssrf: result.ssrf,
-                virtual_patch: result.virtual_patch,
-                xss: result.xss,
-                xxe: result.xxe,
-                no_sqli: result.no_sqli,
-                method_tampering: result.method_tampering,
-                path_traversal_semantic: result.path_traversal_semantic,
-                ssjs: result.ssjs,
-                ip_denylist: result.ip_denylist
-            }
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::RaspRuleSample.include(Contrast::Api::Decorators::RaspRuleSample)

data/lib/contrast/api/decorators/response_type.rb

@@ -1,17 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/api/dtm.pb'
-require 'protobuf/message'
-
-module Contrast
-  module Api
-    module Dtm
-      class AttackResult < ::Protobuf::Message
-        class ResponseType < ::Protobuf::Enum
-          define :SUSPICIOUS, 6
-        end
-      end
-    end
-  end
-end

data/lib/contrast/api/decorators/route_coverage.rb

@@ -1,91 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/utils/string_utils'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::RouteCoverage} protobuf model
-      # to handle conversion between framework route classes and the dtm.
-      module RouteCoverage
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # Class methods for RouteCoverage
-        module ClassMethods
-          def source_or_string obj
-            if obj.cs__is_a?(Regexp)
-              obj.source
-            elsif obj.cs__respond_to?(:safe_string)
-              obj.safe_string
-            else
-              obj.to_s
-            end
-          end
-
-          # Convert ActionDispatch::Journey::Route to Contrast::Api::Dtm::RouteCoverage
-          #
-          # @param journey_obj [ActionDispatch::Journey::Route] a rails route
-          # @param url [String, nil] use url from string instead of journey object.
-          # @return [Contrast::Api::Dtm::RouteCoverage]
-          def from_action_dispatch_journey journey_obj, url = nil
-            msg = new
-            msg.route = "#{ journey_obj.defaults[:controller] }##{ journey_obj.defaults[:action] }"
-
-            verb = source_or_string(journey_obj.verb)
-            msg.verb = Contrast::Utils::StringUtils.force_utf8(verb)
-
-            url ||= source_or_string(journey_obj.path.spec)
-            msg.url = Contrast::Utils::StringUtils.force_utf8(url)
-            msg
-          end
-
-          # Convert Sinatra route data to dtm message.
-          #
-          # @param controller [::Sinatra::Base] the route's final controller.
-          # @param method [String] GET, PUT, POST, etc...
-          # @param pattern [::Mustermann::Sinatra]  the pattern that was matched in routing.
-          # @param url [String, nil] use url from string instead matched pattern.
-          # @return [Contrast::Api::Dtm::RouteCoverage]
-          def from_sinatra_route controller, method, pattern, url = nil
-            safe_pattern = source_or_string(pattern)
-            safe_url = source_or_string(url || pattern)
-
-            msg = new
-            msg.route = "#{ controller }##{ method } #{ safe_pattern }"
-            msg.verb = Contrast::Utils::StringUtils.force_utf8(method)
-            msg.url = Contrast::Utils::StringUtils.force_utf8(safe_url)
-            msg
-          end
-
-          # Convert Grape route data to dtm message.
-          #
-          # @param controller [::Grape::API] the route's final controller.
-          # @param method [String] GET, PUT, POST, etc...
-          # @param url [String, nil] use url from string instead matched pattern.
-          # @param pattern [String, Grape::Router::Route] the pattern that was matched in routing.
-          # @return [Contrast::Api::Dtm::RouteCoverage]
-          def from_grape_controller controller, method, pattern, url = nil
-            if pattern.cs__is_a?(Grape::Router::Route)
-              safe_pattern = pattern.pattern&.path&.to_s
-              safe_url = source_or_string(url || safe_pattern)
-            else
-              safe_pattern = source_or_string(pattern)
-              safe_url = source_or_string(url || pattern)
-            end
-
-            msg = new
-            msg.route = "#{ controller }##{ method } #{ safe_pattern }"
-            msg.verb = Contrast::Utils::StringUtils.force_utf8(method)
-            msg.url = Contrast::Utils::StringUtils.force_utf8(safe_url)
-            msg
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::RouteCoverage.include(Contrast::Api::Decorators::RouteCoverage)

data/lib/contrast/api/decorators/server_features.rb

@@ -1,25 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/utils/string_utils'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Settings::ServerFeatures} protobuf
-      # model to handle setting translation to boolean values.
-      module ServerFeatures
-        # 'defend' is legacy for 'protect' in the dtm.
-        def protect_enabled?
-          !!defend.enabled
-        end
-
-        def assess_enabled?
-          !!assess.enabled
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Settings::ServerFeatures.include(Contrast::Api::Decorators::ServerFeatures)

data/lib/contrast/api/decorators/trace_event.rb

@@ -1,120 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/utils/string_utils'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::TraceEvent} protobuf model to
-      # convert our {Contrast::Agent::AssessContrastEvent} to the dtm.
-      module TraceEvent
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # The TeamServer uses the Event's type and action to render it in the Details page. These values control the
-        # left-hand "What happened" column and the data shown in the right-hand data
-        #
-        # @param contrast_event [Contrast::Agent::Assess::ContrastEvent]
-        # @return [Contrast::Api::Dtm::TraceEvent]
-        def build_display_params! contrast_event
-          self.type = contrast_event.policy_node.node_type
-          self.action = contrast_event.policy_node.build_action
-          self
-        end
-
-        # The TeamServer uses the Event's representation of the data to render the actual data used in the dataflow on
-        # the Details page.
-        #
-        # @param contrast_event [Contrast::Agent::Assess::ContrastEvent]
-        # @return [Contrast::Api::Dtm::TraceEvent]
-        def build_dataflow! contrast_event
-          # Figure out what the target of this event was. This can't be pulled into the decorator because SourceEvent
-          # has a custom impl :/
-          taint_target = contrast_event.determine_taint_target(self)
-          truncate_obj = Contrast::Utils::ObjectShare::OBJECT_KEY != taint_target
-          self.object = Contrast::Api::Dtm::TraceEventObject.build(contrast_event.object, truncate_obj)
-          truncate_ret = Contrast::Utils::ObjectShare::RETURN_KEY != taint_target
-          self.ret = Contrast::Api::Dtm::TraceEventObject.build(contrast_event.ret, truncate_ret)
-          build_event_args!(contrast_event, taint_target)
-          build_taint_ranges!(contrast_event)
-          self
-        end
-
-        # Wrapper around build_event_object for the args array. Handles
-        # tainting the correct argument.
-        # @return [Contrast::Api::Dtm::TraceEvent]
-        def build_event_args! contrast_event, taint_target
-          contrast_event.args.each_index do |idx|
-            truncate_arg = taint_target != idx
-            event_arg = Contrast::Api::Dtm::TraceEventObject.build(contrast_event.args[idx], truncate_arg)
-            args << event_arg
-          end
-          self
-        end
-
-        # TeamServer only supports one object's taint ranges at a time. We keep
-        # those tags on the event directly, so we just need to convert them to
-        # their DTM form in order to report this.
-        #
-        # @param contrast_event [Contrast::Agent::AssessContrastEvent]
-        # @return [Contrast::Api::Dtm::TraceEvent]
-        def build_taint_ranges! contrast_event
-          # If there's no taint_target, this isn't a dataflow trace, but a
-          # trigger one
-          return self unless contrast_event&.tags
-
-          self.taint_ranges += Contrast::Api::Dtm::TraceTaintRange.build_for_event(contrast_event.tags)
-          self
-        end
-
-        # For each Parent in the ContrastEvent, capture its id and report it to TeamServer.
-        #
-        # @param contrast_event [Contrast::Agent::AssessContrastEvent]
-        # @return [Contrast::Api::Dtm::TraceEvent]
-        def build_parent_ids! contrast_event
-          contrast_event&.parent_events&.each do |event|
-            next unless event
-
-            parent = Contrast::Api::Dtm::ParentObjectId.new
-            parent.id = event.event_id.to_i
-            parent_object_ids << parent
-          end
-          self
-        end
-
-        # Convert the caller into the Stack DTM TeamServer consumes
-        #
-        # @param contrast_event [Contrast::Agent::AssessContrastEvent]
-        # @return [Contrast::Api::Dtm::TraceEvent]
-        def build_stack! contrast_event
-          # We delayed doing this as long as possible b/c it's expensive
-          stack_dtms = Contrast::Utils::StackTraceUtils.build_assess_stack_array(contrast_event.stack_trace)
-          self.stack += stack_dtms
-          self
-        end
-
-        # Class methods for TraceEvent
-        module ClassMethods
-          def build contrast_event
-            event_dtm = new
-            event_dtm.build_display_params!(contrast_event)
-            event_dtm.build_dataflow!(contrast_event)
-            event_dtm.build_stack!(contrast_event)
-            event_dtm.timestamp_ms = contrast_event.time.to_i
-            event_dtm.thread = Contrast::Utils::StringUtils.force_utf8(contrast_event.thread)
-            event_dtm.build_parent_ids!(contrast_event)
-            event_dtm.object_id = contrast_event.event_id.to_i
-            event_dtm.signature = Contrast::Api::Dtm::TraceEventSignature.build(contrast_event.ret,
-                                                                                contrast_event.policy_node,
-                                                                                contrast_event.args)
-            event_dtm
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::TraceEvent.include(Contrast::Api::Decorators::TraceEvent)

data/lib/contrast/api/decorators/trace_event_object.rb

@@ -1,63 +0,0 @@
-# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-require 'contrast/utils/string_utils'
-require 'contrast/utils/assess/tracking_util'
-require 'base64'
-require 'contrast/components/scope'
-
-module Contrast
-  module Api
-    module Decorators
-      # Used to decorate the {Contrast::Api::Dtm::TraceEventObject} protobuf
-      # model.
-      module TraceEventObject
-        def self.included klass
-          klass.extend(ClassMethods)
-        end
-
-        # Class methods for TraceEventObject
-        module ClassMethods
-          include Contrast::Components::Scope::InstanceMethods
-          # Build the event object. We were originally going to include taint on
-          # each one, but TS doesn't accept / use that, so it is a waste of time.
-          #
-          # We'll truncate any object that isn't important to the taint ranges of
-          # this event, so that we don't murder TeamServer by, for instance,
-          # hypothetically sending the entire rendered HTML page >_>  <_<  >_>
-          ELLIPSIS = '...'
-          UNTRUNCATED_PORTION_LENGTH = 25
-          TRUNCATION_LENGTH = (UNTRUNCATED_PORTION_LENGTH * 2) + ELLIPSIS.length
-
-          # Convert the given Object into a Contrast::Api::Dtm::TraceEventObject
-          #
-          # @param contrast_object [Contrast::Agent::Assess::ContrastObject, nil]
-          #   the thing to convert, if any
-          # @param truncate [Boolean] if the converted object can/should be
-          #   truncated.
-          # @return [Contrast::Api::Dtm::TraceEventObject]
-          def build contrast_object, truncate
-            event_object = new
-            with_contrast_scope do
-              obj_string = Contrast::Utils::StringUtils.force_utf8(contrast_object&.object)
-              obj_string = truncate(obj_string) if truncate && obj_string.length > TRUNCATION_LENGTH
-              event_object.value = Base64.encode64(obj_string)
-              event_object.tracked = contrast_object&.tracked?
-            end
-            event_object
-          end
-
-          def truncate obj_string
-            tmp = []
-            tmp << obj_string[0, UNTRUNCATED_PORTION_LENGTH]
-            tmp << ELLIPSIS
-            tmp << obj_string[obj_string.length - UNTRUNCATED_PORTION_LENGTH, UNTRUNCATED_PORTION_LENGTH]
-            tmp.join
-          end
-        end
-      end
-    end
-  end
-end
-
-Contrast::Api::Dtm::TraceEventObject.include(Contrast::Api::Decorators::TraceEventObject)