contrast-agent 6.0.0 → 6.1.2

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exception_base.rb

@@ -3,48 +3,56 @@
 
 module Contrast
   module Agent
-    # This class will hold the all the mutual information for the Telemetry Exception
-    class TelemetryExceptionBase
-      def to_controlled_hash; end
+    module Telemetry
+      module TelemetryException
+        # This class will hold the all the mutual information for the Telemetry Exception
+        class Base
+          def to_controlled_hash; end
 
-      protected
+          protected
 
-      # Validate required and option fields
-      #
-      # @param validations [Hash] Validation hash to use
-      # @return [nil]
-      def validate validations
-        validations.each do |k, v|
-          next if v[:required] == false
+          # Validate required and option fields
+          #
+          # @param validations [Hash] Validation hash to use
+          # @return [nil]
+          def validate validations
+            validations.each do |k, v|
+              next if v[:required] == false
 
-          validate_field validations[k], k
-        end
-        nil
-      end
+              validate_field(validations[k], k)
+            end
+            nil
+          end
 
-      # This method will validate every single field passed from validate
-      #
-      # @param validation_pair [Hash] Validation hash to use
-      # @param key[String] The key to check in VALIDATIONS
-      def validate_field validation_pair, key
-        value_to_validate = send(key.to_sym)
-        validate_class value_to_validate, validation_pair[:class], key if validation_pair.key?(:class)
-        value_length = value_to_validate.cs__is_a?(String) ? value_to_validate.length : value_to_validate.entries.length
-        unless validation_pair[:range].include?(value_length)
-          raise ArgumentError, "The provided value for #{ key } is invalid"
-        end
+          # This method will validate every single field passed from validate
+          #
+          # @param validation_pair [Hash] Validation hash to use
+          # @param key[String] The key to check in VALIDATIONS
+          def validate_field validation_pair, key
+            value_to_validate = send(key.to_sym)
+            validate_class(value_to_validate, validation_pair[:class], key) if validation_pair.key?(:class)
+            value_length = if value_to_validate.cs__is_a?(String) || value_to_validate.cs__is_a?(Array)
+                             value_to_validate.length
+                           else
+                             value_to_validate.entries.length
+                           end
+            unless validation_pair[:range].include?(value_length)
+              raise(ArgumentError, "The provided value for #{ key } is invalid: #{ value_to_validate }")
+            end
 
-        nil
-      end
+            nil
+          end
 
-      # With the all nested classes, we still need to double check if everything passed along the way
-      # is right
-      # @param message [Object] The message we want to check the class of
-      # @param klass [Class] The klass we want to check the message with
-      # @param field [Object] The field with the error
-      def validate_class message, klass, field
-        message = message[0] if message.cs__is_a?(Array)
-        raise ArgumentError, "The provided value for #{ field } is invalid" unless message.cs__is_a? klass
+          # With the all nested classes, we still need to double check if everything passed along the way
+          # is right
+          # @param message [Object] The message we want to check the class of
+          # @param klass [Class] The klass we want to check the message with
+          # @param field [Object] The field with the error
+          def validate_class message, klass, field
+            message = message[0] if message.cs__is_a?(Array)
+            raise(ArgumentError, "The provided value for #{ field } is of wrong class") unless message.cs__is_a?(klass)
+          end
+        end
       end
     end
   end

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exception_event.rb

@@ -6,30 +6,38 @@ require_relative 'telemetry_exception_message'
 
 module Contrast
   module Agent
-    # This class will hold the basic information for a Parent Telemetry Exception Event
-    class TelemetryExceptionEvent < Contrast::Agent::TelemetryExceptionBase
-      # Array of Telemetry Exclusions
-      # @return [Array<Contrast::Agent::TelemetryExceptionMessage>]
-      attr_reader :exclusions
+    module Telemetry
+      module TelemetryException
+        # This class will hold the basic information for a Parent Telemetry Exception Event
+        class Event < Contrast::Agent::Telemetry::TelemetryException::Base
+          # Array of Telemetry Exceptions
+          # @return [Array<Contrast::Agent::Telemetry::TelemetryException::Message>]
+          attr_reader :exceptions
 
-      # Initialization of the Parent Event requires us to require the exception
-      # to be created
-      #
-      # @param message [Contrast::Agent::TelemetryExceptionMessage]
-      def initialize message
-        super()
-        validate_class message, Contrast::Agent::TelemetryExceptionMessage, 'exception_message'
-        @exclusions = Array.new(1, message)
-      end
+          # Initialization of the Parent Event requires us to require the exception
+          # to be created
+          #
+          # @param message [Contrast::Agent::Telemetry::TelemetryException::Message]
+          def initialize message
+            super()
+            validate_class(message, Contrast::Agent::Telemetry::TelemetryException::Message, 'exception_message')
+            @exceptions = Array.new(1, message)
+          end
 
-      # @param message [Contrast::Agent::TelemetryExceptionMessage]
-      def push message
-        validate_class message, Contrast::Agent::TelemetryExceptionMessage, 'exception_message'
-        @exclusions << message
-      end
+          # @param message [Contrast::Agent::Telemetry::TelemetryException::Message]
+          def push message
+            validate_class(message, Contrast::Agent::Telemetry::TelemetryException::Message, 'exception_message')
+            @exceptions << message
+          end
+
+          def self.path
+            '/ruby/runtime'
+          end
 
-      def to_controlled_hash
-        exclusions.map(&:to_controlled_hash)
+          def to_controlled_hash
+            exceptions.map(&:to_controlled_hash)
+          end
+        end
       end
     end
   end

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exception_message.rb

@@ -3,94 +3,112 @@
 
 require_relative 'telemetry_exception_base'
 require_relative 'telemetry_exception_message_exception'
+require 'contrast/utils/telemetry_identifier'
 
 module Contrast
   module Agent
-    # This class will hold the all the information for the specific exceptions
-    # and will be passed in the the event to be sent to TS
-    class TelemetryExceptionMessage < Contrast::Agent::TelemetryExceptionBase
-      VALIDATIONS = {
-          instance: { required: true, range: 12..64 },
-          tags: { required: true, range: 1..512 },
-          logger: { required: false, range: 1..128 },
-          message: { required: false, range: 1..512 },
-          exceptions: { required: true, range: 1..512, class: Contrast::Agent::TelemetryExceptionMessageException }
-      }.cs__freeze
+    module Telemetry
+      module TelemetryException
+        # This class will hold the all the information for the specific exceptions
+        # and will be passed in the the event to be sent to TS
+        class Message < Contrast::Agent::Telemetry::TelemetryException::Base
+          VALIDATIONS = {
+              instance: { required: true, range: 12..64 },
+              tags: { required: true, range: 0..512 },
+              logger: { required: false, range: 1..128 },
+              message: { required: false, range: 1..512 },
+              exceptions: {
+                  required: true,
+                  range: 1..512,
+                  class: Contrast::Agent::Telemetry::TelemetryException::MessageException
+              }
+          }.cs__freeze
 
-      # Timestamp of creation in ISO8601 format
-      # @return [Integer]
-      attr_reader :timestamp
+          # Timestamp of creation in ISO8601 format
+          # @return [Integer]
+          attr_reader :timestamp
 
-      # An Instance ID as defined in Unique Identification // Application ID
-      # @return [String]
-      attr_reader :instance
+          # An Instance ID as defined in Unique Identification // Application ID
+          # @return [String]
+          attr_reader :instance
 
-      # Tags are key-value string pairs that annotate either metrics
-      # or errors to help provide context, filtering, grouping, and deduplication.
-      # @return [Hash{String => String}]
-      attr_reader :tags
+          # Tags are key-value string pairs that annotate either metrics
+          # or errors to help provide context, filtering, grouping, and deduplication.
+          # @return [Hash{String => String}]
+          attr_reader :tags
 
-      # @return [Integer] A number of the occurrences of the exception
-      attr_accessor :occurrences
+          # @return [Integer] A number of the occurrences of the exception
+          attr_accessor :occurrences
 
-      # Array of exceptions, but in our case the Array will only include one exception
-      # @return [Array<Contrast::Agent::TelemetryExceptionMessageException>]
-      attr_reader :exceptions
+          # Array of exceptions, but in our case the Array will only include one exception
+          # @return [Array<Contrast::Agent::Telemetry::TelemetryException::MessageException>]
+          attr_reader :exceptions
 
-      # @return [String,nil] A string denoting the origin of this error.
-      attr_reader :logger
+          # @return [String,nil] A string denoting the origin of this error.
+          attr_reader :logger
 
-      # @return [String | nil] A string message to provide additional context to the errors.
-      attr_reader :message
+          # @return [String | nil] A string message to provide additional context to the errors.
+          attr_reader :message
 
-      def initialize instance, tags, exceptions
-        super()
-        @tags = tags
-        @timestamp = Time.now.iso8601
-        @instance = instance
-        @occurrences = 1
-        @exceptions = exceptions
-        validate VALIDATIONS
-      end
+          def initialize instance, tags, exceptions
+            super()
+            @tags = tags
+            @timestamp = Time.now.iso8601
+            @instance = instance
+            @occurrences = 1
+            @exceptions = exceptions
+            validate(VALIDATIONS)
+          end
 
-      # Optional parameters will be set separately from the required
-      #
-      # @param logger[String]
-      def logger= logger
-        validate_field VALIDATIONS[:logger], 'logger'
-        @logger = logger
-      end
+          # Optional parameters will be set separately from the required
+          #
+          # @param logger[String]
+          def logger= logger
+            validate_field(VALIDATIONS[:logger], 'logger')
+            @logger = logger
+          end
 
-      # Optional parameters will be set separately from the required
-      #
-      # @param message[String]
-      def message= message
-        validate_field VALIDATIONS[:message], 'message'
-        @message = message
-      end
+          # Optional parameters will be set separately from the required
+          #
+          # @param message[String]
+          def message= message
+            validate_field(VALIDATIONS[:message], 'message')
+            @message = message
+          end
 
-      # Optional parameters will be set separately from the required
-      # This method is different and is regarding the way we proceed
-      # with incrementing occurrences
-      # If we keep track of them in different places and we store that value
-      # in separated variable - we may directly re-assign occurrences=
-      # But if we are not doing that - we may on same message generated
-      # to increment occurrences from here
-      def increment_occurrences
-        @occurrences += 1
-      end
+          # Optional parameters will be set separately from the required
+          # This method is different and is regarding the way we proceed
+          # with incrementing occurrences
+          # If we keep track of them in different places and we store that value
+          # in separated variable - we may directly re-assign occurrences=
+          # But if we are not doing that - we may on same message generated
+          # to increment occurrences from here
+          def increment_occurrences
+            @occurrences += 1
+          end
+
+          def to_controlled_hash
+            super()
+            {
+                timestamp: timestamp,
+                instance: instance,
+                occurrences: occurrences,
+                tags: tags,
+                exceptions: exceptions.map(&:to_controlled_hash),
+                logger: logger,
+                message: message
+            }.compact
+          end
 
-      def to_controlled_hash
-        super()
-        {
-            timestamp: timestamp,
-            instance: instance,
-            occurrences: occurrences,
-            tags: tags,
-            exceptions: exceptions.map(&:to_controlled_hash),
-            logger: logger,
-            message: message
-        }.compact
+          class << self
+            def build tags, exceptions, logger = nil, message = nil
+              inst = new(Contrast::Utils::Telemetry::Identifier.instance_id, tags, exceptions)
+              inst.logger = logger unless logger.nil?
+              inst.message = message unless message.nil?
+              inst
+            end
+          end
+        end
       end
     end
   end

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exception_message_exception.rb

@@ -6,59 +6,77 @@ require_relative 'telemetry_exception_stack_frame'
 
 module Contrast
   module Agent
-    # This class will hold the all the information for the specific exception
-    # and will be passed in the Exception message itself
-    class TelemetryExceptionMessageException < Contrast::Agent::TelemetryExceptionBase
-      VALIDATIONS = {
-          type: { required: true, range: 1..256 },
-          module_name: { required: false, range: 1..256 },
-          value: { required: false, range: 1..256 },
-          stack_frames: { required: true, range: 1..128, class: Contrast::Agent::TelemetryExceptionStackFrame }
-      }.cs__freeze
+    module Telemetry
+      module TelemetryException
+        # This class will hold the all the information for the specific exception
+        # and will be passed in the Exception message itself
+        class MessageException < Contrast::Agent::Telemetry::TelemetryException::Base
+          VALIDATIONS = {
+              type: { required: true, range: 1..256 },
+              module_name: { required: false, range: 1..256 },
+              value: { required: false, range: 1..256 },
+              stack_frames: {
+                  required: true,
+                  range: 1..128,
+                  class: Contrast::Agent::Telemetry::TelemetryException::StackFrame
+              }
+          }.cs__freeze
 
-      # @return [String] The type of the exception itself
-      attr_reader :type
+          # @return [String] The type of the exception itself
+          attr_reader :type
 
-      # @return [Array<Contrast::Agent::TelemetryExceptionStackFrame>] stack frames for the message exception
-      attr_reader :stack_frames
+          # stack frames for the message exception
+          # @return [Array<Contrast::Agent::Telemetry::TelemetryException::StackFrame>]
+          attr_reader :stack_frames
 
-      # @return [String]
-      attr_reader :module_name
+          # @return [String]
+          attr_reader :module_name
 
-      # @return [String]
-      attr_reader :value
+          # @return [String]
+          attr_reader :value
 
-      def initialize type, stack_frame
-        super()
-        @type = type
-        @stack_frames = Array.new(1, stack_frame)
-        validate VALIDATIONS
-      end
+          def initialize type, stack_frame
+            super()
+            @type = type
+            @stack_frames = Array.new(1, stack_frame)
+            validate(VALIDATIONS)
+          end
 
-      # @param stack_frame [Contrast::Agent::TelemetryExceptionStackFrame]
-      def push stack_frame
-        validate_class stack_frame, Contrast::Agent::TelemetryExceptionStackFrame, 'stack_frame'
-        @stack_frames << stack_frame
-      end
+          # @param stack_frame [Contrast::Agent::Telemetry::TelemetryException::StackFrame]
+          def push stack_frame
+            validate_class(stack_frame, Contrast::Agent::Telemetry::TelemetryException::StackFrame, 'stack_frame')
+            @stack_frames << stack_frame
+          end
 
-      def module_name= module_name
-        validate_field VALIDATIONS[:module_name], 'module_name'
-        @module_name = module_name
-      end
+          def module_name= module_name
+            @module_name = module_name
+            validate_field(VALIDATIONS[:module_name], 'module_name')
+          end
 
-      def value= value
-        validate_field VALIDATIONS[:value], 'value'
-        @value = value
-      end
+          def value= value
+            @value = value
+            validate_field(VALIDATIONS[:value], 'value')
+          end
+
+          def to_controlled_hash
+            super
+            {
+                type: type,
+                module: module_name,
+                stackFrames: stack_frames.map(&:to_controlled_hash),
+                value: value
+            }.compact
+          end
 
-      def to_controlled_hash
-        super
-        {
-            type: type,
-            stack_frames: stack_frames.map(&:to_controlled_hash),
-            module_name: module_name,
-            value: value
-        }.compact
+          class << self
+            def build type, value, module_name, stackframes
+              inst = new(type, stackframes)
+              inst.module_name = module_name if module_name
+              inst.value = value
+              inst
+            end
+          end
+        end
       end
     end
   end

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exception_stack_frame.rb

@@ -5,42 +5,59 @@ require_relative 'telemetry_exception_base'
 
 module Contrast
   module Agent
-    # This class will hold the all the information for the specific exception
-    # and will be passed in the Exception message itself
-    class TelemetryExceptionStackFrame < Contrast::Agent::TelemetryExceptionBase
-      VALIDATIONS = {
-          function: { required: true, range: 1..256 },
-          type: { required: true, range: 1..256 },
-          module_name: { required: false, range: 1..256 }
-      }.cs__freeze
-
-      # @return [String] The type of the exception itself
-      attr_reader :type
-
-      # @return [String] the function of the stack trace
-      attr_reader :function
-
-      # @return [Boolean] Is it in contrast
-      attr_accessor :in_contrast
-
-      def initialize function, type
-        super()
-        @function = function
-        @type = type
-        @in_contrast = false
-        validate VALIDATIONS
-      end
+    module Telemetry
+      module TelemetryException
+        # This class will hold the all the information for the specific exception
+        # and will be passed in the Exception message itself
+        class StackFrame < Contrast::Agent::Telemetry::TelemetryException::Base
+          VALIDATIONS = {
+              function: { required: true, range: 1..256 },
+              type: { required: true, range: 1..256 },
+              module_name: { required: false, range: 1..256 }
+          }.cs__freeze
 
-      attr_reader :module_name
+          # @return [String] The type of the exception itself
+          attr_reader :type
 
-      def module_name= module_name
-        validate_field VALIDATIONS[:module_name], 'module_name'
-        @module_name = module_name
-      end
+          # @return [String] the function of the stack trace
+          attr_reader :function
+
+          # @return [Boolean] Is it in contrast
+          attr_accessor :in_contrast
+
+          # @return [String]
+          attr_reader :module_name
+
+          def initialize function, type
+            super()
+            @function = function
+            @type = type
+            @in_contrast = false
+            validate(VALIDATIONS)
+          end
+
+          def module_name= module_name
+            @module_name = module_name
+            validate_field(VALIDATIONS[:module_name], 'module_name')
+          end
+
+          def to_controlled_hash
+            super
+            { function: function, type: type, module: module_name, inContrast: in_contrast }.compact
+          end
 
-      def to_controlled_hash
-        super
-        { function: function, type: type, inContrast: in_contrast, module_name: module_name }.compact
+          class << self
+            # @param method [String] method, triggered the logger on warn/error/fatal
+            # @param type [String] the type ( where it occurred )
+            # @param module_name [String, nil] Name of the module if any.
+            def build method, type, module_name = nil
+              inst = new(method, type)
+              inst.module_name = module_name if module_name
+              inst.in_contrast = type.include?('lib/contrast')
+              inst
+            end
+          end
+        end
       end
     end
   end

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exceptions.rb

@@ -0,0 +1,20 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This is the module that will include every information created and stored for the
+      # Telemetry Exceptions
+      module TelemetryException
+      end
+    end
+  end
+end
+
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_base'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_stack_frame'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_message_exception'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_message'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exception_event'
+require 'contrast/agent/telemetry/events/exceptions/telemetry_exceptions_report'

data/lib/contrast/agent/telemetry/events/exceptions/telemetry_exceptions_report.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This module will handle the reporting of the TelemetryExceptionHash
+      module TelemetryExceptionReport
+        # Here we will send any exceptions gathered. The telemetry_hash is split into batches of 256
+        # and then added to the telemetry queue. Since this method is called before entering the
+        # until queue loop any updates after clearing the Contrast::TELEMETRY_EXCEPTIONS would have
+        # to wait for the sending process to be completed, so accumulating new batches.
+        # This methods expects queue and error_messages methods from Contrast::Agent::Telemetry::Base
+        def push_exceptions
+          return unless Contrast::TELEMETRY_EXCEPTIONS&.any?
+
+          Contrast::TELEMETRY_EXCEPTIONS.values.each_slice(256) { |tuple| error_messages.push(tuple) }
+          # Clear the hash. All exceptions now live in @_error_messages instance variable. and we will
+          # add them to the queue. Clearing would make the hash available to be populated again while the
+          # sending is proceeding.
+          Contrast::TELEMETRY_EXCEPTIONS.clear
+          # Add batch to queue. We need to shift here, because we want to report from the oldest batch to
+          # the newest. And even if somehow the array is filled during sending the new messages would stay
+          # and wait their turn.
+          queue << error_messages.shift until error_messages.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# Copyright (c) 2022 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/events/event'
+
+module Contrast
+  module Agent
+    module Telemetry
+      # This class will hold the basic information for a Telemetry Event
+      class MetricEvent < Contrast::Agent::Telemetry::Event
+        include Contrast::Utils
+
+        attr_reader :fields
+
+        def initialize
+          super
+          @fields = MetricsHash.new(Numeric)
+          @fields['_filler'] = 0
+        end
+
+        def to_hash **_args
+          super.merge!({ fields: @fields })
+        end
+      end
+    end
+  end
+end