cw-datadog 2.23.0.2

data/lib/datadog/di/el/compiler.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    module EL
+      # DI Expression Language compiler.
+      #
+      # Converts AST in probe definitions into Expression objects.
+      #
+      # WARNING: this class produces strings that are then eval'd as
+      # Ruby code. Input ASTs are user-controlled. As such the compiler
+      # must sanitize and escape all input to avoid injection.
+      #
+      # Besides quotes and backslashes we must also escape # which is
+      # starting string interpolation (#{...}).
+      #
+      # @api private
+      class Compiler
+        def compile(ast)
+          compile_partial(ast)
+        end
+
+        private
+
+        OPERATORS = {
+          'eq' => '==',
+          'ne' => '!=',
+          'ge' => '>=',
+          'gt' => '>',
+          'le' => '<=',
+          'lt' => '<',
+        }.freeze
+
+        SINGLE_ARG_METHODS = %w[
+          len isEmpty isUndefined
+        ].freeze
+
+        TWO_ARG_METHODS = %w[
+          startsWith endsWith contains matches
+          getmember index instanceof
+        ].freeze
+
+        MULTI_ARG_METHODS = {
+          'and' => '&&',
+          'or' => '||',
+        }.freeze
+
+        def compile_partial(ast)
+          case ast
+          when Hash
+            if ast.length != 1
+              raise DI::Error::InvalidExpression, "Expected hash of length 1: #{ast}"
+            end
+            op, target = ast.first
+            case op
+            when 'ref'
+              unless String === target
+                raise DI::Error::InvalidExpression, "Bad ref value type: #{target.class}: #{target}"
+              end
+              case target
+              when '@it'
+                'current_item'
+              when '@key'
+                'current_key'
+              when '@value'
+                'current_value'
+              when '@return'
+                # For @return, @duration and @exception we shadow
+                # instance variables.
+                "context.return_value"
+              when '@duration'
+                # There is no way to explicitly format the duration.
+                # TODO come up with better formatting?
+                # We could format to a string here but what if customer
+                # has @duration as part of an expression and wants
+                # to retain it as a number?
+                "(context.duration * 1000)"
+              when '@exception'
+                "context.exception"
+              else
+                # Ruby technically allows all kinds of symbols in variable
+                # names, for example spaces and many characters.
+                # Start out with strict validation to avoid possible
+                # surprises and need to escape.
+                unless target =~ %r{\A(@?)([a-zA-Z0-9_]+)\z}
+                  raise DI::Error::BadVariableName, "Bad variable name: #{target}"
+                end
+                method_name = (($1 == '@') ? 'iref' : 'ref')
+                "#{method_name}('#{target}')"
+              end
+            when *SINGLE_ARG_METHODS
+              method_name = op.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }
+              "#{method_name}(#{compile_partial(target)}, '#{var_name_maybe(target)}')"
+            when *TWO_ARG_METHODS
+              method_name = op.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }
+              unless Array === target && target.length == 2
+                raise DI::Error::InvalidExpression, "Improper #{op} syntax"
+              end
+              first, second = target
+              "#{method_name}(#{compile_partial(first)}, (#{compile_partial(second)}))"
+            when *MULTI_ARG_METHODS.keys
+              unless Array === target && target.length >= 1
+                raise DI::Error::InvalidExpression, "Improper #{op} syntax"
+              end
+              compiled_targets = target.map do |item|
+                "(#{compile_partial(item)})"
+              end
+              compiled_op = MULTI_ARG_METHODS[op]
+              "(#{compiled_targets.join(" #{compiled_op} ")})"
+            when 'substring'
+              unless Array === target && target.length == 3
+                raise DI::Error::InvalidExpression, "Improper #{op} syntax"
+              end
+              "#{op}(#{target.map { |arg| "(#{compile_partial(arg)})" }.join(", ")})"
+            when 'not'
+              "!(#{compile_partial(target)})"
+            when *OPERATORS.keys
+              unless Array === target && target.length == 2
+                raise DI::Error::InvalidExpression, "Improper #{op} syntax"
+              end
+              first, second = target
+              operator = OPERATORS.fetch(op)
+              "(#{compile_partial(first)}) #{operator} (#{compile_partial(second)})"
+            when 'any', 'all', 'filter'
+              "#{op}(#{compile_partial(target.first)}) { |current_item, current_key, current_value| #{compile_partial(target.last)} }"
+            else
+              raise DI::Error::InvalidExpression, "Unknown operation: #{op}"
+            end
+          when Numeric, true, false, nil
+            # No escaping is needed for the values here.
+            ast.inspect
+          when String
+            "\"#{escape(ast)}\""
+          when Array
+            # Arrays are commonly used as arguments of operators/methods,
+            # but there are no arrays at the top level in the syntax that
+            # we currently understand. Provide a helpful error message in case
+            # syntax is expanded in the future.
+            raise DI::Error::InvalidExpression, "Array is not valid at its location, do you need to upgrade dd-trace-rb? #{ast}"
+          else
+            raise DI::Error::InvalidExpression, "Unknown type in AST: #{ast}"
+          end
+        end
+
+        # Returns a textual description of +target+ for use in exception
+        # messages. +target+ could be any expression language expression.
+        # WARNING: the result of this method is included in eval'd code,
+        # it must be sanitized to avoid injection.
+        def var_name_maybe(target)
+          if Hash === target && target.length == 1 && target.keys.first == 'ref' &&
+              String === (value = target.values.first)
+            escape(value)
+          else
+            '(expression)'
+          end
+        end
+
+        def escape(needle)
+          needle.gsub("\\") { "\\\\" }.gsub('"') { "\\\"" }.gsub('#') { "\\#" }
+        end
+      end
+    end
+  end
+end

data/lib/datadog/di/el/evaluator.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    module EL
+      # Evaluator for expression language.
+      #
+      # @api private
+      class Evaluator
+        def ref(var)
+          @context.fetch(var)
+        end
+
+        def iref(var)
+          @context.fetch_ivar(var)
+        end
+
+        def len(var, var_name)
+          case var
+          when Array, String, Hash
+            var.length
+          else
+            raise DI::Error::ExpressionEvaluationError, "Unsupported type for length: #{var.class}: #{var_name}"
+          end
+        end
+
+        def is_empty(var, var_name)
+          case var
+          when nil, Numeric
+            false
+          when Array, String
+            var.empty?
+          else
+            raise DI::Error::ExpressionEvaluationError, "Unsupported type for isEmpty: #{var.class}: #{var_name}"
+          end
+        end
+
+        def is_undefined(var, var_name)
+          var.nil?
+        end
+
+        def contains(haystack, needle)
+          if String === haystack && String === needle or # standard:disable Style/AndOr
+              Array === haystack
+            haystack.include?(needle)
+          else
+            raise DI::Error::ExpressionEvaluationError, "Invalid arguments for contains: #{haystack}, #{needle}"
+          end
+        end
+
+        def matches(haystack, needle)
+          re = Regexp.compile(needle)
+          !!(haystack =~ re)
+        end
+
+        def getmember(object, field)
+          object.instance_variable_get("@#{field}")
+        end
+
+        def index(array_or_hash, index_or_key)
+          case array_or_hash
+          when Array
+            case index_or_key
+            when Integer
+              array_or_hash[index_or_key]
+            else
+              raise DI::Error::ExpressionEvaluationError, "Invalid index value: #{index_or_key}"
+            end
+          when Hash
+            array_or_hash[index_or_key]
+          else
+            raise DI::Error::ExpressionEvaluationError, "Invalid argument for index: #{array_or_hash}"
+          end
+        end
+
+        def substring(object, from, to)
+          unless String === object
+            raise DI::Error::ExpressionEvaluationError, "Invalid type for substring: #{object}"
+          end
+          object[from...to]
+        end
+
+        def starts_with(haystack, needle)
+          # To guard against running arbitrary customer code, check that
+          # the haystack is a string. This does not help if customer
+          # overrode String#start_with? but at least it's better than nothing.
+          String === haystack && haystack.start_with?(needle)
+        end
+
+        def ends_with(haystack, needle)
+          String === haystack && haystack.end_with?(needle)
+        end
+
+        def all(collection, &block)
+          case collection
+          when Array
+            collection.all? do |item|
+              block.call(item)
+            end
+          when Hash
+            # For hashes, the expression language has both @it and
+            # @key/@value. Manufacture @it from the key and value.
+            collection.all? do |key, value|
+              block.call([key, value], key, value)
+            end
+          else
+            raise DI::Error::ExpressionEvaluationError, "Bad collection type for all: #{collection.class}"
+          end
+        end
+
+        def any(collection, &block)
+          case collection
+          when Array
+            collection.any? do |item|
+              block.call(item)
+            end
+          when Hash
+            collection.any? do |key, value|
+              # For hashes, the expression language has both @it and
+              # @key/@value. Manufacture @it from the key and value.
+              block.call([key, value], key, value)
+            end
+          else
+            raise DI::Error::ExpressionEvaluationError, "Bad collection type for any: #{collection.class}"
+          end
+        end
+
+        def filter(collection, &block)
+          case collection
+          when Array
+            collection.select do |item|
+              block.call(item)
+            end
+          when Hash
+            collection.select do |key, value|
+              block.call([key, value], key, value)
+            end.to_h
+          else
+            raise DI::Error::ExpressionEvaluationError, "Bad collection type for filter: #{collection.class}"
+          end
+        end
+
+        def instanceof(object, cls_name)
+          cls = object.class
+          loop do
+            if cls.name == cls_name
+              return true
+            end
+            if supercls = cls.superclass # standard:disable Lint/AssignmentInCondition
+              cls = supercls
+            else
+              return false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/di/el/expression.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    module EL
+      # Represents an Expression Language expression.
+      #
+      # @api private
+      class Expression
+        def initialize(dsl_expr, compiled_expr)
+          unless String === compiled_expr
+            raise ArgumentError, "compiled_expr must be a string"
+          end
+
+          @dsl_expr = dsl_expr
+
+          cls = Class.new(Evaluator)
+          cls.class_exec do
+            eval(<<-RUBY, Object.new.send(:binding), __FILE__, __LINE__ + 1) # standard:disable Security/Eval
+              def evaluate(context)
+                @context = context
+                #{compiled_expr}
+              end
+            RUBY
+          end
+          @evaluator = cls.new
+        end
+
+        attr_reader :dsl_expr
+        attr_reader :evaluator
+
+        def evaluate(context)
+          @evaluator.evaluate(context)
+        end
+
+        def satisfied?(context)
+          !!evaluate(context)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/di/el.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'el/expression'
+require_relative 'el/compiler'
+require_relative 'el/evaluator'

data/lib/datadog/di/error.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    # Base class for Dynamic Instrumentation exceptions.
+    #
+    # None of these exceptions should be propagated out of DI to user
+    # applications, therefore these exceptions are not considered to be
+    # part of the public API of the library.
+    #
+    # @api private
+    class Error < StandardError
+      # Internal Dynamic Instrumentation error ("should never happen").
+      class InternalError < Error
+      end
+
+      # Probe does not contain a line number (i.e., is not a line probe).
+      class MissingLineNumber < Error
+      end
+
+      # Failed to communicate to the local Datadog agent (e.g. to send
+      # probe status or a snapshot).
+      class AgentCommunicationError < Error
+      end
+
+      # Attempting to instrument a method or file which does not exist.
+      #
+      # This could be due to the code that is referenced in the probe
+      # having not been loaded yet, or due to the probe referencing code
+      # that does not in fact exist anywhere (e.g. due to a misspelling).
+      class DITargetNotDefined < Error
+      end
+
+      # Attempting to instrument a line and the file containing the line
+      # was loaded prior to code tracking being enabled.
+      class DITargetNotInRegistry < Error
+      end
+
+      # Raised when trying to install a probe whose installation failed
+      # earlier in the same process. This exception should contain the
+      # original exception report from initial installation attempt.
+      class ProbePreviouslyFailed < Error
+      end
+
+      # Raised when installing a line probe and multiple files match the
+      # specified path suffix.
+      # A probe must be installed into one file only, since UI only
+      # supports one instrumented location for a probe.
+      # If multiple files match, UI cannot properly render the data from
+      # all of them, and arbitrarily choosing one file may be not what the
+      # user intended. Instrumentation will fail when multiple files match
+      # and the user will need to make their suffix more precise.
+      class MultiplePathsMatch < Error
+      end
+
+      # Base class for exceptions arising during expression language AST
+      # compilation into Ruby code.
+      #
+      # Expression language does not specify behavior in all cases,
+      # leaving some choices to the language implementation in the tracers.
+      # It is therefore possible that some technically valid expressions are
+      # prohibited by our implementation.
+      #
+      # It is also possible that the sanitizers/validators prohibit some
+      # esoteric constructs that are technically valid in Ruby,
+      # for example if instance variable name rules are relaxed to allow
+      # arbitrary characters in them as permitted in method names.
+      class InvalidExpression < Error
+      end
+
+      # Variable name with invalid characters in an expression language
+      # expression.
+      class BadVariableName < InvalidExpression
+      end
+
+      # Base class for exceptions arising when evaluating expression language
+      # expressions.
+      class ExpressionEvaluationError < Error
+      end
+    end
+  end
+end

data/lib/datadog/di/extensions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../core/configuration"
+require_relative "configuration"
+
+module Datadog
+  module DI
+    # Extends Datadog tracing with DI features
+    module Extensions
+      # Inject DI into global objects.
+      def self.activate!
+        Core::Configuration::Settings.extend(Configuration::Settings)
+      end
+    end
+  end
+end