datadog-lambda 0.4.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d37e92d79f90e4049e303719d3639560e7b025e20a62c2199342603e9f76f71d
-  data.tar.gz: c82eb5b84734b2621220eb402e57ba1f88855f39ba94e6567bdde4a6bc6ea80c
+  metadata.gz: 15ddc462886c4a35ba66d327ebbc2be17c403b2d47cab973fa06e05d6df3d2d1
+  data.tar.gz: b90918aa8b2372e2149e4b084b5ee97d9a8268ebff7ebb83a0e1a6a3751488c1
 SHA512:
-  metadata.gz: d6154dce5ec1743195799df476f5b0da7f13db96015822ecfcc4b42e560ba042b9b403355b33a060417c05efa2b9a99975e8fedc540cfea73c1f8e872b8d3985
-  data.tar.gz: 649a76d46ce8fc2ab5f22590137448ec77d518f7f27cb7518300a90ee00fae638250de6ebb486bcf8c3346fa7074257f901dab00b643b30b32e8a2611cf919e1
+  metadata.gz: 71b82b6b3ec47c17fff39fb4f3bfd40c6d2ef7ba477baa82de83a87bc710fc0114fa7aadc84153908db40de6af8437248e9634b8838a6d60af54e44fefbe8e29
+  data.tar.gz: ca9afd36577caa6b5efef5663add0b37e32bfa953b55ee2909bc2f104a139e0a6478fcddcdde67687537672ae88b2d50f81b3d79c4aefa2967c29cae4faf367b

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'
@@ -18,26 +19,57 @@ module Datadog
   # Instruments AWS Lambda functions with Datadog distributed tracing and
   # 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
+        )
+        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)
+    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
       ensure
         @listener.on_end
+        @is_cold_start = false
       end
       res
     end
 
     # Gets the current tracing context
     def self.trace_context
-      Datadog::Trace.trace_context
+      context = Hash[Datadog::Trace.trace_context]
+      context.delete(:source)
+      context
     end
 
     # Send a custom distribution metric
@@ -58,5 +90,88 @@ module Datadog
       metric = { e: time_ms, m: name, t: tag_list, v: value }.to_json
       puts metric
     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}",
+        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,
+    # and adding the enhanced metric tags to the enhanced metrics.
+    # @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
+
+    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)
+      true
+    end
+
+    # Check the DD_ENHANCED_METRICS environment variable
+    # @reurn [boolean] true if this lambda should have
+    # enhanced metrics
+    def self.do_enhanced_metrics?
+      dd_enhanced_metrics = ENV['DD_ENHANCED_METRICS']
+      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,39 @@ 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
+        )
+        options[:resource] = @handler_name
+        options[:service] =  @function_name
+        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/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

@@ -12,7 +12,7 @@ module Datadog
   module Lambda
     module VERSION
       MAJOR = 0
-      MINOR = 4
+      MINOR = 9
       PATCH = 0
       PRE = nil
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-lambda
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 2020-07-23 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.32'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.32'
 - !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-layer-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