ddtrace 0.52.0 → 0.54.2

data/lib/ddtrace/contrib/active_job/patcher.rb

@@ -0,0 +1,33 @@
+# typed: false
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/events'
+require 'ddtrace/contrib/active_job/log_injection'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      # Patcher enables patching of 'active_job' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          Events.subscribe!
+          inject_log_correlation if Datadog.configuration[:active_job][:log_injection]
+        end
+
+        def inject_log_correlation
+          ::ActiveSupport.on_load(:active_job) do
+            include LogInjection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/auto_instrument.rb

@@ -1,5 +1,4 @@
 # typed: false
-require 'ddtrace'
 
 module Datadog
   module Contrib

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -9,7 +9,7 @@ module Datadog
       # DelayedJob plugin that instruments invoke_job hook
       class Plugin < Delayed::Plugin
         def self.instrument_invoke(job, &block)
-          return block.call(job) unless tracer && tracer.enabled
+          return yield(job) unless tracer && tracer.enabled
 
           tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name(job),
                                       on_error: configuration[:error_handler]) do |span|
@@ -29,7 +29,7 @@ module Datadog
         end
 
         def self.instrument_enqueue(job, &block)
-          return block.call(job) unless tracer && tracer.enabled
+          return yield(job) unless tracer && tracer.enabled
 
           tracer.trace(Ext::SPAN_ENQUEUE, service: configuration[:client_service_name], resource: job_name(job)) do |span|
             set_sample_rate(span)

data/lib/ddtrace/contrib/mongodb/instrumentation.rb

@@ -52,7 +52,7 @@ module Datadog
           module InstanceMethods
             def datadog_pin
               @datadog_pin ||= begin
-                service = Datadog.configuration[:mongo][:service_name]
+                service = Datadog.configuration[:mongo, seed][:service_name]
 
                 Datadog::Pin.new(
                   service,

data/lib/ddtrace/contrib/mongodb/integration.rb

@@ -1,5 +1,6 @@
 # typed: false
 require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
 require 'ddtrace/contrib/mongodb/configuration/settings'
 require 'ddtrace/contrib/mongodb/patcher'
 
@@ -33,6 +34,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
       end
     end
   end

data/lib/ddtrace/contrib/rails/auto_instrument_railtie.rb

@@ -1,5 +1,4 @@
 # typed: ignore
-require 'ddtrace'
 
 # Railtie to include AutoInstrumentation in rails loading
 class DatadogAutoInstrumentRailtie < Rails::Railtie

data/lib/ddtrace/contrib/rails/configuration/settings.rb

@@ -73,6 +73,13 @@ module Datadog
             end
           end
 
+          option :job_service do |o|
+            o.on_set do |value|
+              # Update ActiveJob service name too
+              Datadog.configuration[:active_job][:service_name] = value
+            end
+          end
+
           option :middleware, default: true
           option :middleware_names, default: false
           option :template_base_path do |o|

data/lib/ddtrace/contrib/rails/framework.rb

@@ -5,6 +5,7 @@ require 'ddtrace/ext/app_types'
 require 'ddtrace/contrib/active_record/integration'
 require 'ddtrace/contrib/active_support/integration'
 require 'ddtrace/contrib/action_cable/integration'
+require 'ddtrace/contrib/action_mailer/integration'
 require 'ddtrace/contrib/action_pack/integration'
 require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/grape/endpoint'
@@ -21,7 +22,7 @@ module Datadog
       # Rails framework code, used to essentially:
       # - handle configuration entries which are specific to Datadog tracing
       # - instrument parts of the framework when needed
-      module Framework
+      module Framework # rubocop:disable Metrics/ModuleLength
         # After the Rails application finishes initializing, we configure the Rails
         # integration and all its sub-components with the application information
         # available.
@@ -45,9 +46,11 @@ module Datadog
 
             activate_rack!(datadog_config, rails_config)
             activate_action_cable!(datadog_config, rails_config)
+            activate_action_mailer!(datadog_config, rails_config)
             activate_active_support!(datadog_config, rails_config)
             activate_action_pack!(datadog_config, rails_config)
             activate_action_view!(datadog_config, rails_config)
+            activate_active_job!(datadog_config, rails_config)
             activate_active_record!(datadog_config, rails_config)
             activate_lograge!(datadog_config, rails_config)
             activate_semantic_logger!(datadog_config, rails_config)
@@ -62,6 +65,7 @@ module Datadog
             config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
             config[:controller_service] ||= config[:service_name]
             config[:cache_service] ||= "#{config[:service_name]}-cache"
+            config[:job_service] ||= "#{config[:service_name]}-#{Contrib::ActiveJob::Ext::SERVICE_NAME}"
           end
         end
 
@@ -93,6 +97,15 @@ module Datadog
           )
         end
 
+        def self.activate_action_mailer!(datadog_config, rails_config)
+          return unless defined?(::ActionMailer)
+
+          datadog_config.use(
+            :action_mailer,
+            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionMailer::Ext::SERVICE_NAME}"
+          )
+        end
+
         def self.activate_action_pack!(datadog_config, rails_config)
           return unless defined?(::ActionPack)
 
@@ -115,6 +128,16 @@ module Datadog
           )
         end
 
+        def self.activate_active_job!(datadog_config, rails_config)
+          return unless defined?(::ActiveJob)
+
+          datadog_config.use(
+            :active_job,
+            service_name: rails_config[:job_service],
+            log_injection: rails_config[:log_injection]
+          )
+        end
+
         def self.activate_active_record!(datadog_config, rails_config)
           return unless defined?(::ActiveRecord)
 

data/lib/ddtrace/contrib/rails/patcher.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 require 'ddtrace/contrib/rails/utils'
 require 'ddtrace/contrib/rails/framework'
 require 'ddtrace/contrib/rails/middlewares'
@@ -45,17 +45,26 @@ module Datadog
         end
 
         def add_middleware(app)
-          # Add trace middleware
+          # Add trace middleware at the top of the middleware stack,
+          # to ensure we capture the complete execution time.
           app.middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
 
-          # Insert right after Rails exception handling middleware, because if it's before,
-          # it catches and swallows the error. If it's too far after, custom middleware can find itself
-          # between, and raise exceptions that don't end up getting tagged on the request properly.
-          # e.g lost stack trace.
-          app.middleware.insert_after(
-            ActionDispatch::ShowExceptions,
-            Datadog::Contrib::Rails::ExceptionMiddleware
-          )
+          # Some Rails middleware can swallow an application error, preventing
+          # the error propagation to the encompassing Rack span.
+          #
+          # We insert our own middleware right before these Rails middleware
+          # have a chance to swallow the error.
+          #
+          # Note: because the middleware stack is push/pop, "before" and "after" are reversed
+          # for our use case: we insert ourselves with "after" a middleware to ensure we are
+          # able to pop the request "before" it.
+          if defined?(::ActionDispatch::DebugExceptions)
+            # Rails >= 3.2
+            app.middleware.insert_after(::ActionDispatch::DebugExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
+          else
+            # Rails < 3.2
+            app.middleware.insert_after(::ActionDispatch::ShowExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
+          end
         end
 
         def add_logger(app)

data/lib/ddtrace/contrib/redis/instrumentation.rb

@@ -0,0 +1,90 @@
+# typed: false
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/redis/ext'
+require 'ddtrace/contrib/redis/configuration/resolver'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Instrumentation for Redis
+      module Instrumentation
+        def self.included(base)
+          base.prepend(InstanceMethods)
+        end
+
+        # InstanceMethods - implementing instrumentation
+        module InstanceMethods
+          def call(*args, &block)
+            pin = Datadog::Pin.get_from(self)
+            return super unless pin && pin.tracer
+
+            response = nil
+            pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
+              span.service = pin.service
+              span.span_type = Datadog::Contrib::Redis::Ext::TYPE
+              span.resource = get_command(args)
+              Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+              response = super
+            end
+
+            response
+          end
+
+          def call_pipeline(*args, &block)
+            pin = Datadog::Pin.get_from(self)
+            return super unless pin && pin.tracer
+
+            response = nil
+            pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
+              span.service = pin.service
+              span.span_type = Datadog::Contrib::Redis::Ext::TYPE
+              commands = get_pipeline_commands(args)
+              span.resource = commands.join("\n")
+              span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
+              Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+
+              response = super
+            end
+
+            response
+          end
+
+          def datadog_pin
+            @datadog_pin ||= begin
+              pin = Datadog::Pin.new(
+                datadog_configuration[:service_name],
+                app: Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB,
+                tracer: -> { datadog_configuration[:tracer] }
+              )
+              pin.onto(self)
+            end
+          end
+
+          private
+
+          def get_command(args)
+            if datadog_configuration[:command_args]
+              Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+            else
+              Datadog::Contrib::Redis::Quantize.get_verb(*args)
+            end
+          end
+
+          def get_pipeline_commands(args)
+            if datadog_configuration[:command_args]
+              args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+            else
+              args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.get_verb(c) }
+            end
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:redis, options]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/redis/patcher.rb

@@ -23,92 +23,10 @@ module Datadog
           require 'ddtrace/ext/app_types'
           require 'ddtrace/contrib/redis/tags'
           require 'ddtrace/contrib/redis/quantize'
+          require 'ddtrace/contrib/redis/instrumentation'
 
-          patch_redis_client
+          ::Redis::Client.include(Instrumentation)
         end
-
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/BlockLength
-        # rubocop:disable Metrics/AbcSize
-        def patch_redis_client
-          ::Redis::Client.class_eval do
-            alias_method :call_without_datadog, :call
-            remove_method :call
-            def call(*args, &block)
-              pin = Datadog::Pin.get_from(self)
-              return call_without_datadog(*args, &block) unless pin && pin.tracer
-
-              response = nil
-              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = pin.service
-                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
-                span.resource = get_command(args)
-                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
-
-                response = call_without_datadog(*args, &block)
-              end
-
-              response
-            end
-
-            alias_method :call_pipeline_without_datadog, :call_pipeline
-            remove_method :call_pipeline
-            def call_pipeline(*args, &block)
-              pin = Datadog::Pin.get_from(self)
-              return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
-
-              response = nil
-              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = pin.service
-                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
-                commands = get_pipeline_commands(args)
-                span.resource = commands.join("\n")
-                span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
-                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
-
-                response = call_pipeline_without_datadog(*args, &block)
-              end
-
-              response
-            end
-
-            def datadog_pin
-              @datadog_pin ||= begin
-                pin = Datadog::Pin.new(
-                  datadog_configuration[:service_name],
-                  app: Ext::APP,
-                  app_type: Datadog::Ext::AppTypes::DB,
-                  tracer: -> { datadog_configuration[:tracer] }
-                )
-                pin.onto(self)
-              end
-            end
-
-            private
-
-            def get_command(args)
-              if datadog_configuration[:command_args]
-                Datadog::Contrib::Redis::Quantize.format_command_args(*args)
-              else
-                Datadog::Contrib::Redis::Quantize.get_verb(*args)
-              end
-            end
-
-            def get_pipeline_commands(args)
-              if datadog_configuration[:command_args]
-                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
-              else
-                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.get_verb(c) }
-              end
-            end
-
-            def datadog_configuration
-              Datadog.configuration[:redis, options]
-            end
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/BlockLength
       end
     end
   end

data/lib/ddtrace/contrib/registerable.rb

@@ -1,5 +1,4 @@
 # typed: false
-require 'datadog/contrib'
 
 module Datadog
   module Contrib

data/lib/ddtrace/contrib/resque/integration.rb

@@ -11,8 +11,6 @@ module Datadog
         include Contrib::Integration
 
         MINIMUM_VERSION = Gem::Version.new('1.0')
-        # Maximum is first version it's NOT compatible with (not inclusive)
-        MAXIMUM_VERSION = Gem::Version.new('3.0')
 
         register_as :resque, auto_patch: true
 
@@ -25,9 +23,7 @@ module Datadog
         end
 
         def self.compatible?
-          super \
-            && version >= MINIMUM_VERSION \
-            && version < MAXIMUM_VERSION
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

data/lib/ddtrace/contrib/sidekiq/ext.rb

@@ -15,6 +15,9 @@ module Datadog
         SERVICE_NAME = 'sidekiq'.freeze
         SPAN_PUSH = 'sidekiq.push'.freeze
         SPAN_JOB = 'sidekiq.job'.freeze
+        SPAN_JOB_FETCH = 'sidekiq.job_fetch'.freeze
+        SPAN_HEARTBEAT = 'sidekiq.heartbeat'.freeze
+        SPAN_SCHEDULED_PUSH = 'sidekiq.scheduled_push'.freeze
         TAG_JOB_DELAY = 'sidekiq.job.delay'.freeze
         TAG_JOB_ID = 'sidekiq.job.id'.freeze
         TAG_JOB_QUEUE = 'sidekiq.job.queue'.freeze

data/lib/ddtrace/contrib/sidekiq/integration.rb

@@ -11,6 +11,7 @@ module Datadog
         include Contrib::Integration
 
         MINIMUM_VERSION = Gem::Version.new('3.5.4')
+        MINIMUM_SERVER_INTERNAL_TRACING_VERSION = Gem::Version.new('5.2.4')
 
         register_as :sidekiq
 
@@ -26,6 +27,15 @@ module Datadog
           super && version >= MINIMUM_VERSION
         end
 
+        # Only patch server internals on v5.2.4+ because that's when loading of
+        # `Sidekiq::Launcher` stabilized. Sidekiq 4+ technically can support our
+        # patches (with minor adjustments), but in order to avoid explicitly
+        # requiring `sidekiq/launcher` ourselves (which could affect gem
+        # initialization order), we are limiting this tracing to v5.2.4+.
+        def self.compatible_with_server_internal_tracing?
+          version >= MINIMUM_SERVER_INTERNAL_TRACING_VERSION
+        end
+
         def default_configuration
           Configuration::Settings.new
         end

data/lib/ddtrace/contrib/sidekiq/patcher.rb

@@ -34,8 +34,34 @@ module Datadog
             config.server_middleware do |chain|
               chain.add(Sidekiq::ServerTracer)
             end
+
+            patch_server_internals if Integration.compatible_with_server_internal_tracing?
           end
         end
+
+        def patch_server_internals
+          patch_server_heartbeat
+          patch_server_job_fetch
+          patch_server_scheduled_push
+        end
+
+        def patch_server_heartbeat
+          require 'ddtrace/contrib/sidekiq/server_internal_tracer/heartbeat'
+
+          ::Sidekiq::Launcher.prepend(ServerInternalTracer::Heartbeat)
+        end
+
+        def patch_server_job_fetch
+          require 'ddtrace/contrib/sidekiq/server_internal_tracer/job_fetch'
+
+          ::Sidekiq::Processor.prepend(ServerInternalTracer::JobFetch)
+        end
+
+        def patch_server_scheduled_push
+          require 'ddtrace/contrib/sidekiq/server_internal_tracer/scheduled_push'
+
+          ::Sidekiq::Scheduled::Poller.prepend(ServerInternalTracer::ScheduledPush)
+        end
       end
     end
   end

data/lib/ddtrace/contrib/sidekiq/server_internal_tracer/heartbeat.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      module ServerInternalTracer
+        # Trace when a Sidekiq process has a heartbeat
+        module Heartbeat
+          private
+
+          def ❤ # rubocop:disable Naming/AsciiIdentifiers, Naming/MethodName
+            configuration = Datadog.configuration[:sidekiq]
+
+            configuration[:tracer].trace(Ext::SPAN_HEARTBEAT) do |span|
+              span.service = configuration[:service_name]
+              span.span_type = Datadog::Ext::AppTypes::WORKER
+
+              # Set analytics sample rate
+              if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+              end
+
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sidekiq/server_internal_tracer/job_fetch.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      module ServerInternalTracer
+        # Trace when Sidekiq looks for another job to work
+        module JobFetch
+          private
+
+          def fetch
+            configuration = Datadog.configuration[:sidekiq]
+
+            configuration[:tracer].trace(Ext::SPAN_JOB_FETCH) do |span|
+              span.service = configuration[:service_name]
+              span.span_type = Datadog::Ext::AppTypes::WORKER
+
+              # Set analytics sample rate
+              if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+              end
+
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sidekiq/server_internal_tracer/scheduled_push.rb

@@ -0,0 +1,29 @@
+# typed: true
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      module ServerInternalTracer
+        # Trace when Sidekiq checks to see if there are scheduled jobs that need to be worked
+        # https://github.com/mperham/sidekiq/wiki/Scheduled-Jobs
+        module ScheduledPush
+          def enqueue
+            configuration = Datadog.configuration[:sidekiq]
+
+            configuration[:tracer].trace(Ext::SPAN_SCHEDULED_PUSH) do |span|
+              span.service = configuration[:service_name]
+              span.span_type = Datadog::Ext::AppTypes::WORKER
+
+              # Set analytics sample rate
+              if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+              end
+
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/sinatra/env.rb

@@ -10,7 +10,8 @@ module Datadog
         module_function
 
         def datadog_span(env, app)
-          env[Ext::RACK_ENV_REQUEST_SPAN][app]
+          request_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+          request_span && request_span[app]
         end
 
         def set_datadog_span(env, app, span)

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -5,7 +5,7 @@ require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/errors'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
-
+require 'ddtrace/utils/only_once'
 require 'ddtrace/contrib/sinatra/ext'
 require 'ddtrace/contrib/sinatra/tracer_middleware'
 require 'ddtrace/contrib/sinatra/env'
@@ -77,6 +77,9 @@ module Datadog
 
         # Method overrides for Sinatra::Base
         module Base
+          MISSING_REQUEST_SPAN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+          private_constant :MISSING_REQUEST_SPAN_ONLY_ONCE
+
           def render(engine, data, *)
             tracer = Datadog.configuration[:sinatra][:tracer]
             return super unless tracer.enabled
@@ -121,8 +124,18 @@ module Datadog
                 else
                   Sinatra::Env.datadog_span(env, self.class)
                 end
-              if sinatra_request_span # DEV: Is it possible for sinatra_request_span to ever be nil here?
+              if sinatra_request_span
                 sinatra_request_span.resource = span.resource
+              else
+                MISSING_REQUEST_SPAN_ONLY_ONCE.run do
+                  Datadog.logger.warn do
+                    'Sinatra integration is misconfigured, reported traces will be missing request metadata ' \
+                    'such as path and HTTP status code. ' \
+                    'Did you forget to add `register Datadog::Contrib::Sinatra::Tracer` to your ' \
+                    '`Sinatra::Base` subclass? ' \
+                    'See <https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#sinatra> for more details.'
+                  end
+                end
               end
 
               Contrib::Analytics.set_measured(span)

data/lib/ddtrace/ext/git.rb

@@ -15,6 +15,18 @@ module Datadog
       TAG_COMMIT_COMMITTER_NAME = 'git.commit.committer.name'.freeze
       TAG_COMMIT_MESSAGE = 'git.commit.message'.freeze
       TAG_COMMIT_SHA = 'git.commit.sha'.freeze
+
+      ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'.freeze
+      ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'.freeze
+      ENV_BRANCH = 'DD_GIT_BRANCH'.freeze
+      ENV_TAG = 'DD_GIT_TAG'.freeze
+      ENV_COMMIT_MESSAGE = 'DD_GIT_COMMIT_MESSAGE'.freeze
+      ENV_COMMIT_AUTHOR_NAME = 'DD_GIT_COMMIT_AUTHOR_NAME'.freeze
+      ENV_COMMIT_AUTHOR_EMAIL = 'DD_GIT_COMMIT_AUTHOR_EMAIL'.freeze
+      ENV_COMMIT_AUTHOR_DATE = 'DD_GIT_COMMIT_AUTHOR_DATE'.freeze
+      ENV_COMMIT_COMMITTER_NAME = 'DD_GIT_COMMIT_COMMITTER_NAME'.freeze
+      ENV_COMMIT_COMMITTER_EMAIL = 'DD_GIT_COMMIT_COMMITTER_EMAIL'.freeze
+      ENV_COMMIT_COMMITTER_DATE = 'DD_GIT_COMMIT_COMMITTER_DATE'.freeze
     end
   end
 end