elastic-apm 1.1.0 → 2.0.0

data/lib/elastic_apm/transaction.rb

@@ -5,144 +5,113 @@ require 'securerandom'
 module ElasticAPM
   # @api private
   class Transaction
-    DEFAULT_TYPE = 'custom'.freeze
+    extend Deprecations
 
-    # rubocop:disable Metrics/MethodLength
+    DEFAULT_TYPE = 'custom'
+
+    # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
     def initialize(
-      instrumenter,
       name = nil,
       type = nil,
+      sampled: true,
       context: nil,
-      sampled: true
+      tags: nil,
+      traceparent: nil
     )
-      @id = SecureRandom.uuid
-      @instrumenter = instrumenter
       @name = name
       @type = type || DEFAULT_TYPE
 
-      @timestamp = Util.micros
+      @sampled = sampled
 
-      @spans = []
-      @span_id_ticker = -1
-      @dropped_spans = 0
+      @context = context || Context.new # TODO: Lazy generate this?
+      Util.reverse_merge!(@context.tags, tags) if tags
 
-      @notifications = [] # for AS::Notifications
+      @id = SecureRandom.hex(8)
 
-      @context = context || Context.new
-      @context.tags.merge!(instrumenter.config.default_tags) { |_, old, _| old }
+      if traceparent
+        @traceparent = traceparent
+        @parent_id = traceparent.span_id
+      else
+        @traceparent = Traceparent.from_transaction(self)
+      end
 
-      @sampled = sampled
+      @started_spans = 0
+      @dropped_spans = 0
 
-      yield self if block_given?
+      @notifications = [] # for AS::Notifications
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength
 
-    attr_accessor :name, :type
-    attr_reader :id, :context, :duration, :dropped_spans, :root_span,
-      :timestamp, :spans, :result, :notifications, :sampled, :instrumenter
+    attr_accessor :name, :type, :result
 
-    def release
-      @instrumenter.current_transaction = nil
-    end
+    attr_reader :id, :context, :duration, :started_spans, :dropped_spans,
+      :timestamp, :traceparent, :notifications, :parent_id
 
-    def done(result = nil)
-      @duration = Util.micros - @timestamp
-      @result = result
+    def sampled?
+      @sampled
+    end
 
-      self
+    def stopped?
+      !!duration
     end
 
     def done?
-      !!@duration
+      stopped?
     end
 
-    def submit(result = nil, status: nil, headers: {})
-      done result unless duration
-
-      if status
-        context.response = Context::Response.new(status, headers: headers)
-      end
-
-      release
-
-      @instrumenter.submit_transaction self
+    deprecate :done?, :stopped?
 
-      self
+    def trace_id
+      traceparent&.trace_id
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def span(name, type = nil, backtrace: nil, context: nil)
-      unless sampled?
-        return yield if block_given?
-        return
-      end
+    # life cycle
 
-      if spans.length >= instrumenter.config.transaction_max_spans
-        @dropped_spans += 1
-
-        return yield if block_given?
-        return
-      end
-
-      span = build_and_start_span(name, type, context, backtrace)
-
-      return span unless block_given?
-
-      begin
-        result = yield span
-      ensure
-        span.done
-      end
-
-      result
+    def start
+      @timestamp = Util.micros
+      self
     end
-    # rubocop:enable Metrics/MethodLength
 
-    def current_span
-      spans.reverse.lazy.find(&:running?)
+    def stop
+      raise 'Transaction not yet start' unless timestamp
+      @duration = Util.micros - timestamp
+      self
     end
 
-    def sampled?
-      !!sampled
+    def done(result = nil)
+      stop
+      self.result = result if result
+      self
     end
 
-    def inspect
-      "<ElasticAPM::Transaction id:#{id}" \
-        " name:#{name.inspect}" \
-        " type:#{type.inspect}" \
-        '>'
+    def ensure_parent_id
+      @parent_id ||= SecureRandom.hex(8)
+      @parent_id
     end
 
-    private
+    # spans
 
-    def next_span_id
-      @span_id_ticker += 1
+    def inc_started_spans!
+      @started_spans += 1
     end
 
-    def next_span(name, type, context)
-      Span.new(
-        self,
-        next_span_id,
-        name,
-        type,
-        parent: current_span,
-        context: context
-      )
+    def inc_dropped_spans!
+      @dropped_spans += 1
     end
 
-    def span_frames_min_duration?
-      @instrumenter.agent.config.span_frames_min_duration != 0
+    def max_spans_reached?(config)
+      started_spans > config.transaction_max_spans
     end
 
-    def build_and_start_span(name, type, context, backtrace)
-      span = next_span(name, type, context)
-      spans << span
+    # context
 
-      if backtrace && span_frames_min_duration?
-        span.original_backtrace = backtrace
-      end
+    def add_response(*args)
+      context.response = Context::Response.new(*args)
+    end
 
-      span.start
+    def inspect
+      "<ElasticAPM::Transaction id:#{id}" \
+        " name:#{name.inspect} type:#{type.inspect}>"
     end
   end
 end

data/lib/elastic_apm/transport/base.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/transport/connection'
+require 'elastic_apm/transport/worker'
+
+require 'elastic_apm/transport/serializers'
+require 'elastic_apm/transport/filters'
+
+module ElasticAPM
+  module Transport
+    # @api private
+    class Base
+      include Logging
+
+      def initialize(config)
+        @config = config
+        @queue = SizedQueue.new(config.api_buffer_size)
+        @pool = Concurrent::FixedThreadPool.new(config.pool_size)
+        @workers = []
+
+        @serializers = Serializers.new(config)
+        @filters = Filters.new(config)
+      end
+
+      attr_reader :config, :queue, :workers, :filters
+
+      def start
+        ensure_worker_count
+      end
+
+      def stop
+        stop_workers
+      end
+
+      def submit(resource)
+        queue.push(resource, true)
+
+        ensure_worker_count
+      rescue ThreadError
+        warn 'Queue is full (%i items), skipping…', config.api_buffer_size
+        nil
+      end
+
+      def add_filter(key, callback)
+        @filters.add(key, callback)
+      end
+
+      private
+
+      def ensure_worker_count
+        missing = config.pool_size - @workers.length
+        return unless missing > 0
+
+        info 'Booting %i workers', missing
+        missing.times { boot_worker }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def boot_worker
+        worker = Worker.new(
+          config,
+          queue,
+          serializers: @serializers,
+          filters: @filters
+        )
+
+        @workers.push worker
+
+        @pool.post do
+          worker.work_forever
+          @workers.delete(worker)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def stop_workers
+        return unless @pool.running?
+
+        debug 'Stopping workers'
+        send_stop_messages
+
+        debug 'Shutting down pool'
+        @pool.shutdown
+
+        return if @pool.wait_for_termination(5)
+
+        warn "Worker pool didn't close in 5 secs, killing ..."
+        @pool.kill
+      end
+
+      def send_stop_messages
+        @workers.each { queue.push(Worker::StopMessage.new, true) }
+      rescue ThreadError
+        warn 'Cannot push stop messages to worker queue as it is full'
+      end
+    end
+  end
+end

data/lib/elastic_apm/transport/connection.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'http'
+require 'concurrent'
+require 'zlib'
+
+require 'elastic_apm/metadata'
+
+module ElasticAPM
+  module Transport
+    # @api private
+    class Connection # rubocop:disable Metrics/ClassLength
+      include Logging
+
+      class FailedToConnectError < InternalError; end
+
+      # @api private
+      # HTTP.rb calls #rewind the body stream which IO.pipes don't support
+      class ModdedIO < IO
+        def self.pipe(ext_enc = nil)
+          super(ext_enc).tap do |rw|
+            rw[0].define_singleton_method(:rewind) { nil }
+          end
+        end
+      end
+
+      HEADERS = {
+        'Content-Type' => 'application/x-ndjson',
+        'Transfer-Encoding' => 'chunked'
+      }.freeze
+      GZIP_HEADERS = HEADERS.merge('Content-Encoding' => 'gzip').freeze
+
+      def initialize(config)
+        @config = config
+
+        @url = config.server_url + '/intake/v2/events'
+
+        headers =
+          (@config.http_compression? ? GZIP_HEADERS : HEADERS).dup
+
+        if (token = config.secret_token)
+          headers['Authorization'] = "Bearer #{token}"
+        end
+
+        @client = HTTP.headers(headers).persistent(@url)
+
+        @metadata = Metadata.build(config)
+
+        @mutex = Mutex.new
+      end
+
+      def write(str)
+        connect_unless_connected
+
+        @mutex.synchronize { append(str) }
+
+        return unless @bytes_sent >= @config.api_request_size
+
+        flush
+      rescue FailedToConnectError => e
+        error "Couldn't establish connection to APM Server:\n%p", e
+        flush
+
+        nil
+      end
+
+      def connected?
+        @mutex.synchronize { @connected }
+      end
+
+      def flush
+        @mutex.synchronize do
+          return unless @connected
+
+          debug 'Closing request'
+          @wr.close
+          @conn_thread.join 5 if @conn_thread
+        end
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def connect_unless_connected
+        @mutex.synchronize do
+          return true if @connected
+
+          debug 'Opening new request'
+
+          reset!
+
+          @rd, @wr = ModdedIO.pipe
+
+          enable_compression! if @config.http_compression?
+
+          perform_request_in_thread
+          wait_for_connection
+
+          schedule_closing if @config.api_request_time
+
+          append(@metadata)
+
+          true
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def perform_request_in_thread
+        @conn_thread = Thread.new do
+          begin
+            @connected = true
+            resp = @client.post(@url, body: @rd).flush
+          rescue Exception => e
+            @connection_error = e
+          ensure
+            @connected = false
+          end
+
+          if resp&.status == 202
+            debug 'APM Server responded with status 202'
+          elsif resp
+            error "APM Server reponded with an error:\n%p", resp.body.to_s
+          end
+
+          resp
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def append(str)
+        bytes =
+          if @config.http_compression
+            @bytes_sent = @wr.tell
+          else
+            @bytes_sent += str.bytesize
+          end
+
+        debug 'Bytes sent during this request: %d', bytes
+
+        @wr.puts(str)
+      end
+
+      def schedule_closing
+        @close_task =
+          Concurrent::ScheduledTask.execute(@config.api_request_time) do
+            flush
+          end
+      end
+
+      def enable_compression!
+        @wr.binmode
+        @wr = Zlib::GzipWriter.new(@wr)
+      end
+
+      def reset!
+        @bytes_sent = 0
+        @connected = false
+        @connection_error = nil
+        @close_task = nil
+      end
+
+      def wait_for_connection
+        until @connected
+          if (exception = @connection_error)
+            @wr&.close
+            raise FailedToConnectError, exception
+          end
+
+          sleep 0.01
+        end
+      end
+    end
+  end
+end