datadog-lambda 0.5.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8037783498999fb1a3291a4b6c72d13933efc9c4056b08f96e560debf804797d
-  data.tar.gz: 8f1f8794b9fd7a7886715afe3d41e9398e0d110ace2279c5bec2e2a34d2d60d7
+  metadata.gz: c19e8514981117ae88bdaa4d17f7a3a5db19595d39336100ac581e0cf330be1d
+  data.tar.gz: 5d2c0ef21fb1fb0d33759f0b3430daebe88100e4f626b20f6dd9512739c6b62c
 SHA512:
-  metadata.gz: 98545e61a901be1b3441ba52d197ea69dfe6eee9469d571b2a77e979d4f73c56e133cc0d9502c003342a5a78ee50fea4ca4fb0af6ad7bd3a47d9bd8d5aede373
-  data.tar.gz: d27d0e7a1a9774347fa5865ce508b09f91137b56e400614ad15c06ba3492a977e1734b2015d380f1d14c36b896ace3bfc64e4e4839b2533280c8d411c30503c7
+  metadata.gz: 6cab42dc833290ea7742def1dda6e4bb4a89ebb7f90240e053cdbcd8f8a338fbaaa98069dc48fdc6d823fb087a90c946c097bd012014e31b84629995f296fe0a
+  data.tar.gz: 4092f19c6b544307e2a82492fd13ce2241d2e0820df2b81da53a6adbd4ec3da0aa9b6d04a56c528b822f93df36e8122985d1a5c0584773d867c3f787feb46eba

data/lib/datadog/lambda.rb

@@ -7,6 +7,7 @@
 # This product includes software developed at Datadog (https://www.datadoghq.com/).
 # Copyright 2019 Datadog, Inc.
 #
+# rubocop:disable Metrics/ModuleLength
 
 require 'datadog/lambda/trace/listener'
 require 'datadog/lambda/utils/logger'
@@ -19,17 +20,42 @@ module Datadog
   # custom metrics
   module Lambda
     @is_cold_start = true
+    @patch_http = true
+
+    # Configures Datadog's APM tracer with lambda specific defaults.
+    # Same options can be given as Datadog.configure in tracer
+    # See https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md#quickstart-for-ruby-applications
+    def self.configure_apm
+      require 'ddtrace'
+      require 'ddtrace/sync_writer'
+
+      @patch_http = false
+      # Needed to keep trace flushes on a single line
+      $stdout.sync = true
+
+      Datadog.configure do |c|
+        c.tracer writer: Datadog::SyncWriter.new(
+          transport: Datadog::Transport::IO.default
+        )
+        c.tags = { "_dd.origin": 'lambda' }
+        yield(c) if block_given?
+      end
+    end
+
     # Wrap the body of a lambda invocation
     # @param event [Object] event sent to lambda
     # @param context [Object] lambda context
     # @param block [Proc] implementation of the handler function.
     def self.wrap(event, context, &block)
       Datadog::Utils.update_log_level
-      @listener ||= Trace::Listener.new
+      @listener ||= initialize_listener
       @listener.on_start(event: event)
       record_enhanced('invocations', context)
       begin
-        res = block.call
+        cold = @is_cold_start
+        res = @listener.on_wrap(request_context: context, cold_start: cold) do
+          block.call
+        end
       rescue StandardError => e
         record_enhanced('errors', context)
         raise e
@@ -42,7 +68,8 @@ module Datadog
 
     # Gets the current tracing context
     def self.trace_context
-      Datadog::Trace.trace_context
+      context = Hash[Datadog::Trace.trace_context]
+      context
     end
 
     # Send a custom distribution metric
@@ -55,34 +82,59 @@ module Datadog
       raise 'value must be a number' unless value.is_a?(Numeric)
 
       time ||= Time.now
-      tag_list = ['dd_lambda_layer:datadog-ruby25']
+      time_ms = time.to_f.to_i
+
+      tag_list = ["dd_lambda_layer:datadog-ruby#{dd_lambda_layer_tag}"]
       tags.each do |tag|
         tag_list.push("#{tag[0]}:#{tag[1]}")
       end
-      time_ms = time.to_f.to_i
-      metric = { e: time_ms, m: name, t: tag_list, v: value }.to_json
-      puts metric
+      metric = { e: time_ms, m: name, t: tag_list, v: value }
+      puts metric.to_json
+    end
+
+    def self.dd_lambda_layer_tag
+      RUBY_VERSION[0, 3].tr('.', '')
     end
 
     # Generate tags for enhanced metrics
     # @param context [Object] https://docs.aws.amazon.com/lambda/latest/dg/ruby-context.html
     # @return [hash] a hash of the enhanced metrics tags
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def self.gen_enhanced_tags(context)
       arn_parts = context.invoked_function_arn.split(':')
-      {
+      # Check if we have an alias or version
+      function_alias = arn_parts[7].nil? ? nil : arn_parts[7]
+
+      tags = {
         functionname: context.function_name,
         region: arn_parts[3],
         account_id: arn_parts[4],
         memorysize: context.memory_limit_in_mb,
         cold_start: @is_cold_start,
-        runtime: "Ruby #{RUBY_VERSION}"
+        runtime: "Ruby #{RUBY_VERSION}",
+        resource: context.function_name
       }
+      # If we have an alias...
+      unless function_alias.nil?
+        # If the alis version is $Latest, drop the $ for ddog tag convention.
+        if function_alias.start_with?('$')
+          function_alias[0] = ''
+          # If the alias is not a version number add the executed version tag
+        elsif !/\A\d+\z/.match(function_alias)
+          tags[:executedversion] = context.function_version
+        end
+        # Append the alias to the resource tag
+        tags[:resource] = context.function_name + ':' + function_alias
+      end
+
+      tags
     rescue StandardError => e
       Datadog::Utils.logger.error 'Unable to parse Lambda context' \
       "#{context}: #{e}"
       {}
     end
 
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     # Format and add tags to enhanced metrics
     # This method wraps the metric method, checking the DD_ENHANCED_METRICS
     # environment variable, adding 'aws.lambda.enhanced' to the metric name,
@@ -90,13 +142,13 @@ module Datadog
     # @param metric_name [String] basic name of the metric
     # @param context [Object] AWS Ruby Lambda Context
     # @return [boolean] false if the metric was not added for some reason,
-    #   true otherwise (for ease of testing)
+    #   true otherwise (for ease of testing
 
     def self.record_enhanced(metric_name, context)
       return false unless do_enhanced_metrics?
 
       etags = gen_enhanced_tags(context)
-      metric("aws.lambda.enhanced.#{metric_name}", 1, etags)
+      metric("aws.lambda.enhanced.#{metric_name}", 1, **etags)
       true
     end
 
@@ -105,9 +157,26 @@ module Datadog
     # enhanced metrics
     def self.do_enhanced_metrics?
       dd_enhanced_metrics = ENV['DD_ENHANCED_METRICS']
-      return false if dd_enhanced_metrics.nil?
+      return true if dd_enhanced_metrics.nil?
 
       dd_enhanced_metrics.downcase == 'true'
     end
+
+    def self.initialize_listener
+      handler = ENV['_HANDLER'].nil? ? 'handler' : ENV['_HANDLER']
+      function = ENV['AWS_LAMBDA_FUNCTION_NAME']
+      merge_xray_traces = false
+      merge_xray_traces_env = ENV['DD_MERGE_DATADOG_XRAY_TRACES']
+      unless merge_xray_traces_env.nil?
+        merge_xray_traces = merge_xray_traces_env.downcase == 'true'
+        Datadog::Utils.logger.debug("Setting merge traces #{merge_xray_traces}")
+      end
+
+      Trace::Listener.new(handler_name: handler,
+                          function_name: function,
+                          patch_http: @patch_http,
+                          merge_xray_traces: merge_xray_traces)
+    end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/datadog/lambda/trace/constants.rb

@@ -20,5 +20,11 @@ module Datadog
     DD_XRAY_SUBSEGMENT_NAME = 'datadog-metadata'
     DD_XRAY_SUBSEGMENT_KEY = 'trace'
     DD_XRAY_SUBSEGMENT_NAMESPACE = 'datadog'
+    SOURCE_XRAY = 'XRAY'
+    SOURCE_EVENT = 'EVENT'
+    XRAY_ENV_VAR = '_X_AMZN_TRACE_ID'
+    XRAY_UDP_PORT = 2000
+    LOCAL_HOST = '127.0.0.1'
+    AWS_XRAY_DAEMON_ADDRESS_ENV_VAR = 'AWS_XRAY_DAEMON_ADDRESS'
   end
 end

data/lib/datadog/lambda/trace/context.rb

@@ -8,8 +8,8 @@
 # Copyright 2019 Datadog, Inc.
 #
 
-require 'aws-xray-sdk'
 require 'datadog/lambda/trace/constants'
+require 'datadog/lambda/trace/xray'
 require 'datadog/lambda/utils/logger'
 
 module Datadog
@@ -17,56 +17,19 @@ module Datadog
   # lambda events/X-Ray
   module Trace
     class << self
-      def extract_trace_context(event)
+      def extract_trace_context(event, merge_xray_traces)
         context = read_trace_context_from_event(event)
         unless context.nil?
           begin
             add_trace_context_to_xray(context)
           rescue StandardError => e
-            Datadog::Utils.logger.error("couldn't add metadata to xray #{e}")
+            Datadog::Utils.logger.debug("couldn't add metadata to xray #{e}")
           end
           return context
         end
-        read_trace_context_from_xray
-      end
-
-      def add_trace_context_to_xray(context)
-        seg = XRay.recorder.begin_subsegment(
-          DD_XRAY_SUBSEGMENT_NAME,
-          namespace: DD_XRAY_SUBSEGMENT_NAMESPACE
-        )
-        data = {
-          "parent-id": context[:parent_id],
-          "sampling-priority": context[:sample_mode].to_s,
-          "trace-id": context[:trace_id]
-        }
-        seg.metadata(namespace: DD_XRAY_SUBSEGMENT_NAMESPACE)
-           .update("#{DD_XRAY_SUBSEGMENT_KEY}": data)
-        XRay.recorder.end_subsegment
-      end
+        return nil unless merge_xray_traces
 
-      def current_trace_context(trace_context)
-        entity = XRay.recorder.current_entity
-        parent_id = entity.id
-        {
-          trace_id: trace_context[:trace_id],
-          parent_id: convert_to_apm_parent_id(parent_id),
-          sample_mode: trace_context[:sample_mode]
-        }
-      end
-
-      def read_trace_context_from_xray
-        segment = XRay.recorder.current_entity
-        parent_id = segment.id
-        mode = segment.sampled ? SAMPLE_MODE_USER_KEEP : SAMPLE_MODE_USER_REJECT
-        {
-          trace_id: convert_to_apm_trace_id(segment.trace_id),
-          parent_id: convert_to_apm_parent_id(parent_id),
-          sample_mode: mode
-        }
-      rescue StandardError => e
-        Datadog::Utils.logger.error("couldn't read xray trace header #{e}")
-        nil
+        read_trace_context_from_xray
       end
 
       def read_trace_context_from_event(event)
@@ -79,7 +42,8 @@ module Datadog
         {
           trace_id: headers[DD_TRACE_ID_HEADER],
           parent_id: headers[DD_PARENT_ID_HEADER],
-          sample_mode: headers[DD_SAMPLING_PRIORITY_HEADER].to_i
+          sample_mode: headers[DD_SAMPLING_PRIORITY_HEADER].to_i,
+          source: SOURCE_EVENT
         }
       end
 
@@ -99,32 +63,6 @@ module Datadog
         end
         true
       end
-
-      def convert_to_apm_trace_id(xray_trace_id)
-        parts = xray_trace_id.split('-')
-        return nil if parts.length < 3
-
-        last_part = parts[2]
-        return nil if last_part.length != 24
-        # Make sure every character is hex
-        return nil if last_part.upcase[/\H/]
-
-        hex = last_part.to_i(16)
-        last_63_bits = hex & 0x7fffffffffffffff
-        last_63_bits.to_s(10)
-      end
-
-      def convert_to_apm_parent_id(xray_parent_id)
-        return nil if xray_parent_id.length != 16
-        return nil if xray_parent_id.upcase[/\H/]
-
-        hex = xray_parent_id.to_i(16)
-        hex.to_s(10)
-      end
-
-      def convert_to_sample_mode(xray_sampled)
-        xray_sampled == '1' ? SAMPLE_MODE_USER_KEEP : SAMPLE_MODE_USER_REJECT
-      end
     end
   end
 end

data/lib/datadog/lambda/trace/ddtrace.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# ddtrace is an optional dependency for the ruby package
+begin
+  require 'ddtrace'
+rescue LoadError
+  Datadog::Utils.logger.debug 'dd-trace unavailable'
+end
+
+module Datadog
+  # TraceListener tracks tracing context information
+  module Trace
+    class <<self
+      def apply_datadog_trace_context(context)
+        unless context.nil?
+          trace_id = context[:trace_id].to_i
+          span_id = context[:parent_id].to_i
+          sampling_priority = context[:sample_mode]
+          Datadog.tracer.provider.context = Datadog::Context.new(
+            trace_id: trace_id,
+            span_id: span_id,
+            sampling_priority: sampling_priority
+          )
+        end
+      rescue StandardError
+        Datadog::Utils.logger.debug 'dd-trace unavailable'
+      end
+
+      def wrap_datadog(options, &block)
+        tracer_available = false
+        begin
+          Datadog.tracer
+          tracer_available = true
+        rescue StandardError
+          Datadog::Utils.logger.debug 'dd-trace unavailable'
+        end
+        return block.call unless tracer_available
+
+        Datadog.tracer.trace('aws.lambda', options) do |_span|
+          block.call
+        end
+      end
+    end
+  end
+end

data/lib/datadog/lambda/trace/listener.rb

@@ -9,27 +9,25 @@
 #
 
 require 'datadog/lambda/trace/context'
-require 'datadog/lambda/trace/xray_lambda'
 require 'datadog/lambda/trace/patch_http'
-
-require 'aws-xray-sdk'
+require 'datadog/lambda/trace/ddtrace'
 
 module Datadog
   module Trace
     # TraceListener tracks tracing context information
     class Listener
-      def initialize
-        XRay.recorder.configure(
-          patch: %I[aws_sdk],
-          context: Datadog::Trace::LambdaContext.new,
-          streamer: Datadog::Trace::LambdaStreamer.new,
-          emitter: Datadog::Trace::LambdaEmitter.new
-        )
-        Datadog::Trace.patch_http
+      def initialize(handler_name:, function_name:, patch_http:,
+                     merge_xray_traces:)
+        @handler_name = handler_name
+        @function_name = function_name
+        @merge_xray_traces = merge_xray_traces
+
+        Datadog::Trace.patch_http if patch_http
       end
 
       def on_start(event:)
-        trace_context = Datadog::Trace.extract_trace_context(event)
+        trace_context = Datadog::Trace.extract_trace_context(event,
+                                                             @merge_xray_traces)
         Datadog::Trace.trace_context = trace_context
         Datadog::Utils.logger.debug "extracted trace context #{trace_context}"
       rescue StandardError => e
@@ -37,6 +35,42 @@ module Datadog
       end
 
       def on_end; end
+
+      def on_wrap(request_context:, cold_start:, &block)
+        options = get_option_tags(
+          request_context: request_context,
+          cold_start: cold_start
+        )
+        context = Datadog::Trace.trace_context
+        source = context[:source] if context
+        options[:tags]['_dd.parent_source'] = source if source && source != 'ddtrace'
+        options[:resource] = @function_name
+        options[:service] = 'aws.lambda'
+        options[:span_type] = 'serverless'
+        Datadog::Trace.apply_datadog_trace_context(Datadog::Trace.trace_context)
+        Datadog::Trace.wrap_datadog(options) do
+          block.call
+        end
+      end
+
+      private
+
+      def get_option_tags(request_context:, cold_start:)
+        function_arn = request_context.invoked_function_arn.downcase
+        tk = function_arn.split(':')
+        function_arn = tk.length > 7 ? tk[0, 7].join(':') : function_arn
+        function_version = tk.length > 7 ? tk[7] : '$LATEST'
+        options = {
+          tags: {
+            cold_start: cold_start,
+            function_arn: function_arn,
+            function_version: function_version,
+            request_id: request_context.aws_request_id,
+            resource_names: request_context.function_name
+          }
+        }
+        options
+      end
     end
   end
 end

data/lib/datadog/lambda/trace/patch_http.rb

@@ -36,11 +36,7 @@ module Datadog
             Datadog::Trace.trace_context
           )
 
-          req[Datadog::Trace::DD_SAMPLING_PRIORITY_HEADER.to_sym] =
-            context[:sample_mode]
-          req[Datadog::Trace::DD_PARENT_ID_HEADER.to_sym] = context[:parent_id]
-          req[Datadog::Trace::DD_TRACE_ID_HEADER.to_sym] = context[:trace_id]
-          logger.debug("added context #{context} to request")
+          req = add_ctx_to_req(req, context)
         rescue StandardError => e
           trace = e.backtrace.join("\n ")
           logger.debug(
@@ -49,6 +45,17 @@ module Datadog
         end
         super(req, body, &block)
       end
+
+      private
+
+      def add_ctx_to_req(req, context)
+        req[Datadog::Trace::DD_SAMPLING_PRIORITY_HEADER.to_sym] =
+          context[:sample_mode]
+        req[Datadog::Trace::DD_PARENT_ID_HEADER.to_sym] = context[:parent_id]
+        req[Datadog::Trace::DD_TRACE_ID_HEADER.to_sym] = context[:trace_id]
+        logger.debug("added context #{context} to request")
+        req
+      end
     end
   end
 end

data/lib/datadog/lambda/trace/xray.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+#
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache License Version 2.0.
+#
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2019 Datadog, Inc.
+#
+require 'datadog/lambda/trace/constants'
+require 'datadog/lambda/utils/logger'
+require 'securerandom'
+require 'json'
+require 'socket'
+
+module Datadog
+  # Trace contains utilities related to reading/writing trace context from
+  # lambda events/X-Ray
+  module Trace
+    class << self
+      def read_trace_context_from_xray
+        header = ENV[XRAY_ENV_VAR]
+        segment = parse_xray_trace_context_header(header)
+        trace_id = convert_to_apm_trace_id(segment[:xray_trace_id])
+        parent_id = convert_to_apm_parent_id(segment[:xray_parent_id])
+        sample_mode = convert_to_sample_mode(segment[:xray_sample_mode])
+
+        if trace_id.nil? || parent_id.nil? || sample_mode.nil?
+          Datadog::Utils.logger.error("couldn't read xray header #{header}")
+          return nil
+        end
+        {
+          trace_id: trace_id,
+          parent_id: parent_id,
+          sample_mode: sample_mode,
+          source: SOURCE_XRAY
+        }
+      end
+
+      def add_trace_context_to_xray(context)
+        data = generate_xray_metadata_subsegment(context)
+        send_xray_daemon_data(data)
+        Datadog::Utils.logger.debug("sent metadata to xray #{data}")
+      end
+
+      def generate_xray_metadata_subsegment(context)
+        header = ENV[XRAY_ENV_VAR]
+        segment = parse_xray_trace_context_header(header)
+
+        {
+          "id": SecureRandom.hex(8),
+          "trace_id": segment[:xray_trace_id],
+          "parent_id": segment[:xray_parent_id],
+          "name": DD_XRAY_SUBSEGMENT_NAME,
+          "start_time": Time.now.to_f,
+          "end_time": Time.now.to_f,
+          "type": 'subsegment',
+          "metadata": {
+            "datadog": {
+              "trace": {
+                "parent-id": context[:parent_id],
+                "sampling-priority": context[:sample_mode].to_s,
+                "trace-id": context[:trace_id]
+              }
+            }
+          }
+        }.to_json
+      end
+
+      def current_trace_context(trace_context)
+        trace_context = Hash[trace_context]
+        begin
+          # This will only succeed if the user has imported xray themselves
+          entity = XRay.recorder.current_entity
+          trace_context[:parent_id] = convert_to_apm_parent_id(entity.id)
+        rescue StandardError
+          Datadog::Utils.logger.debug("couldn't fetch xray entity")
+        end
+        trace_context
+      end
+
+      def send_xray_daemon_data(data)
+        xray_daemon_env = ENV[AWS_XRAY_DAEMON_ADDRESS_ENV_VAR]
+        socket = XRAY_UDP_PORT
+        address = LOCAL_HOST
+        address, socket = xray_daemon_env.split(':') unless xray_daemon_env.nil?
+
+        sock = UDPSocket.open
+        message = "{\"format\": \"json\", \"version\": 1}\n#{data}"
+        sock.send(message, 0, address, socket)
+      end
+
+      def parse_xray_trace_context_header(header)
+        Datadog::Utils.logger.debug("Reading trace context from env #{header}")
+        trace_id, parent_id, sampled = header.split(';')
+                                             .map { |v| parse_assignment(v) }
+
+        return nil if trace_id.nil? || parent_id.nil? || sampled. nil?
+
+        {
+          xray_trace_id: trace_id,
+          xray_parent_id: parent_id,
+          xray_sample_mode: sampled
+        }
+      end
+
+      def parse_assignment(value)
+        return nil if value.nil?
+
+        _, raw_value, * = value.split('=')
+        raw_value
+      end
+
+      def convert_to_apm_trace_id(xray_trace_id)
+        parts = xray_trace_id.split('-')
+        return nil if parts.length < 3
+
+        last_part = parts[2]
+        return nil if last_part.length != 24
+        # Make sure every character is hex
+        return nil if last_part.upcase[/\H/]
+
+        hex = last_part.to_i(16)
+        last_63_bits = hex & 0x7fffffffffffffff
+        last_63_bits.to_s(10)
+      end
+
+      def convert_to_apm_parent_id(xray_parent_id)
+        return nil if xray_parent_id.length != 16
+        return nil if xray_parent_id.upcase[/\H/]
+
+        hex = xray_parent_id.to_i(16)
+        hex.to_s(10)
+      end
+
+      def convert_to_sample_mode(xray_sampled)
+        xray_sampled == '1' ? SAMPLE_MODE_USER_KEEP : SAMPLE_MODE_USER_REJECT
+      end
+    end
+  end
+end

data/lib/datadog/lambda/version.rb

@@ -11,8 +11,8 @@
 module Datadog
   module Lambda
     module VERSION
-      MAJOR = 0
-      MINOR = 5
+      MAJOR = 1
+      MINOR = 10
       PATCH = 0
       PRE = nil
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-lambda
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.10.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-27 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-xray-sdk
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: 0.11.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.11'
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: ddtrace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -93,12 +107,13 @@ files:
 - lib/datadog/lambda.rb
 - lib/datadog/lambda/trace/constants.rb
 - lib/datadog/lambda/trace/context.rb
+- lib/datadog/lambda/trace/ddtrace.rb
 - lib/datadog/lambda/trace/listener.rb
 - lib/datadog/lambda/trace/patch_http.rb
-- lib/datadog/lambda/trace/xray_lambda.rb
+- lib/datadog/lambda/trace/xray.rb
 - lib/datadog/lambda/utils/logger.rb
 - lib/datadog/lambda/version.rb
-homepage: https://github.com/DataDog/dd-lambda-rb
+homepage: https://github.com/DataDog/datadog-lambda-rb
 licenses:
 - Apache-2.0
 metadata:
@@ -118,8 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Instruments your Ruby AWS Lambda functions with Datadog

data/lib/datadog/lambda/trace/xray_lambda.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Unless explicitly stated otherwise all files in this repository are licensed
-# under the Apache License Version 2.0.
-#
-# This product includes software developed at Datadog (https://www.datadoghq.com/).
-# Copyright 2019 Datadog, Inc.
-#
-
-require 'aws-xray-sdk'
-
-module Datadog
-  module Trace
-    # Workaround to XRay not being supported in Lambda
-    # https://github.com/aws/aws-xray-sdk-ruby/issues/20
-    class LambdaStreamer < XRay::DefaultStreamer
-      def initialize
-        @stream_threshold = 1 # Stream every subsegment as it is available
-      end
-    end
-
-    # LambdaEmitter filters out spans generated from the lambda daemon
-    class LambdaEmitter < XRay::DefaultEmitter
-      def should_send?(entity:)
-        entity.name != '127.0.0.1' # Do not send localhost entities.
-      end
-
-      def send_entity(entity:)
-        return nil unless should_send?(entity: entity)
-
-        super
-      end
-    end
-
-    # LambdaContext updated the trace id based on the curren trace header,
-    # using a FacadeSegment
-    class LambdaContext < XRay::DefaultContext
-      def handle_context_missing
-        nil
-      end
-
-      def check_context
-        # Create a new FacadeSegment if the _X_AMZN_TRACE_ID changes.
-        return if ENV['_X_AMZN_TRACE_ID'] == @current_trace_id
-
-        # puts "XRAY: Starting new segment for #{ENV['_X_AMZN_TRACE_ID']}"
-        @current_trace_id = ENV['_X_AMZN_TRACE_ID']
-        trace_header = XRay::TraceHeader.from_header_string(
-          header_str: @current_trace_id
-        )
-        segment = FacadeSegment.new(trace_id: trace_header.root,
-                                    parent_id: trace_header.parent_id,
-                                    id: trace_header.parent_id,
-                                    name: 'lambda_context',
-                                    sampled: trace_header.sampled)
-        store_entity(entity: segment)
-      end
-
-      def current_entity
-        # ensure the FacadeSegment is current whenever the current_entity is
-        # retrieved
-        check_context
-        super
-      end
-    end
-
-    # FacadeSegment is used to create a mock root span, that segments/
-    # subsegments can be attached to. This span will never be submitted to the
-    # X-Ray daemon
-    class FacadeSegment < XRay::Segment
-      def initialize(trace_id: nil, name: nil, parent_id: nil, id: nil,
-                     sampled: true)
-        super(trace_id: trace_id, name: name, parent_id: parent_id)
-        @id = id
-        @sampled = sampled
-      end
-
-      def ready_to_send?
-        false # never send this facade.
-      end
-    end
-  end
-end