atatus 1.0.0

data/lib/atatus/trace_context.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class TraceContext
+    class InvalidTraceparentHeader < StandardError; end
+
+    VERSION = '00'
+    HEX_REGEX = /[^[:xdigit:]]/.freeze
+
+    TRACE_ID_LENGTH = 16
+    ID_LENGTH = 8
+
+    def initialize(
+      version: VERSION,
+      trace_id: nil,
+      span_id: nil,
+      id: nil,
+      recorded: true
+    )
+      @version = version
+      @trace_id = trace_id || hex(TRACE_ID_LENGTH)
+      # TODO: rename to parent_id with next major version bump
+      @parent_id = span_id
+      @id = id || hex(ID_LENGTH)
+      @recorded = recorded
+    end
+
+    attr_accessor :version, :id, :trace_id, :parent_id, :recorded
+
+    alias :recorded? :recorded
+
+    # rubocop:disable Metrics/AbcSize
+    def self.parse(header)
+      raise InvalidTraceparentHeader unless header.length == 55
+      raise InvalidTraceparentHeader unless header[0..1] == VERSION
+
+      new.tap do |t|
+        t.version, t.trace_id, t.parent_id, t.flags =
+          header.split('-').tap do |values|
+            values[-1] = Util.hex_to_bits(values[-1])
+          end
+
+        raise InvalidTraceparentHeader if HEX_REGEX =~ t.trace_id
+        raise InvalidTraceparentHeader if HEX_REGEX =~ t.parent_id
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def flags=(flags)
+      @flags = flags
+
+      self.recorded = flags[7] == '1'
+    end
+
+    def flags
+      format('0000000%d', recorded? ? 1 : 0)
+    end
+
+    def hex_flags
+      format('%02x', flags.to_i(2))
+    end
+
+    def ensure_parent_id
+      @parent_id ||= hex(ID_LENGTH)
+    end
+
+    def child
+      dup.tap do |tc|
+        tc.parent_id = tc.id
+        tc.id = hex(ID_LENGTH)
+      end
+    end
+
+    def to_header
+      format('%s-%s-%s-%s', version, trace_id, id, hex_flags)
+    end
+
+    private
+
+    def hex(len)
+      SecureRandom.hex(len)
+    end
+  end
+end

data/lib/atatus/transaction.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'forwardable'
+
+module Atatus
+  # @api private
+  class Transaction
+    extend Forwardable
+
+    def_delegators :@trace_context,
+      :trace_id, :parent_id, :id, :ensure_parent_id
+
+    DEFAULT_TYPE = 'custom'
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      name = nil,
+      type = nil,
+      sampled: true,
+      context: nil,
+      labels: nil,
+      trace_context: nil
+    )
+      @name = name
+      @type = type || DEFAULT_TYPE
+
+      @sampled = sampled
+
+      @context = context || Context.new # TODO: Lazy generate this?
+      Util.reverse_merge!(@context.labels, labels) if labels
+
+      @trace_context = trace_context || TraceContext.new(recorded: sampled)
+
+      @started_spans = 0
+      @dropped_spans = 0
+
+      @notifications = [] # for AS::Notifications
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    attr_accessor :name, :type, :result, :spans
+
+    attr_reader :context, :duration, :started_spans, :dropped_spans,
+      :timestamp, :trace_context, :notifications
+
+    def sampled?
+      @sampled
+    end
+
+    def stopped?
+      !!duration
+    end
+
+    # life cycle
+
+    def start(clock_start = Util.monotonic_micros)
+      @timestamp = Util.micros
+      @clock_start = clock_start
+      self
+    end
+
+    def stop(clock_end = Util.monotonic_micros)
+      raise 'Transaction not yet start' unless timestamp
+      @duration = clock_end - @clock_start
+      self
+    end
+
+    def done(result = nil, clock_end: Util.monotonic_micros)
+      stop clock_end
+      self.result = result if result
+      self
+    end
+
+    # spans
+
+    def inc_started_spans!
+      @started_spans += 1
+    end
+
+    def inc_dropped_spans!
+      @dropped_spans += 1
+    end
+
+    def max_spans_reached?(config)
+      started_spans > config.transaction_max_spans
+    end
+
+    # context
+
+    def add_response(*args)
+      context.response = Context::Response.new(*args)
+    end
+
+    def inspect
+      "<Atatus::Transaction id:#{id}" \
+        " name:#{name.inspect} type:#{type.inspect}>"
+    end
+  end
+end

data/lib/atatus/transport/base.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'atatus/metadata'
+require 'atatus/transport/connection'
+require 'atatus/transport/worker'
+require 'atatus/transport/serializers'
+require 'atatus/transport/filters'
+require 'atatus/util/throttle'
+
+module Atatus
+  module Transport
+    # rubocop:disable Metrics/ClassLength
+    # @api private
+    class Base
+      include Logging
+
+      WATCHER_EXECUTION_INTERVAL = 5
+      WATCHER_TIMEOUT_INTERVAL = 4
+      WORKER_JOIN_TIMEOUT = 5
+
+      def initialize(config)
+        @config = config
+        @queue = SizedQueue.new(config.api_buffer_size)
+
+        @serializers = Serializers.new(config)
+        @filters = Filters.new(config)
+
+        @stopped = Concurrent::AtomicBoolean.new
+        @workers = Array.new(config.pool_size)
+
+        @watcher_mutex = Mutex.new
+        @worker_mutex = Mutex.new
+      end
+
+      attr_reader :config, :queue, :filters, :workers, :watcher, :stopped
+
+      def start
+        debug '%s: Starting Transport', pid_str
+
+        ensure_watcher_running
+        ensure_worker_count
+      end
+
+      def stop
+        debug '%s: Stopping Transport', pid_str
+
+        @stopped.make_true
+
+        stop_watcher
+        stop_workers
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def submit(resource)
+        if @stopped.true?
+          warn '%s: Transport stopping, no new events accepted', pid_str
+          return false
+        end
+
+        ensure_watcher_running
+        queue.push(resource, true)
+
+        true
+      rescue ThreadError
+        throttled_queue_full_warning
+        nil
+      rescue Exception => e
+        error '%s: Failed adding to the transport queue: %p', pid_str, e.inspect
+        nil
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def add_filter(key, callback)
+        @filters.add(key, callback)
+      end
+
+      private
+
+      def pid_str
+        format('[PID:%s]', Process.pid)
+      end
+
+      def ensure_watcher_running
+        # pid has changed == we've forked
+        return if @pid == Process.pid
+
+        @watcher_mutex.synchronize do
+          return if @pid == Process.pid
+          @pid = Process.pid
+
+          @watcher = Concurrent::TimerTask.execute(
+            execution_interval: WATCHER_EXECUTION_INTERVAL,
+            timeout_interval: WATCHER_TIMEOUT_INTERVAL
+          ) { ensure_worker_count }
+        end
+      end
+
+      def ensure_worker_count
+        @worker_mutex.synchronize do
+          return if all_workers_alive?
+          return if stopped.true?
+
+          @workers.map! do |thread|
+            next thread if thread&.alive?
+
+            boot_worker
+          end
+        end
+      end
+
+      def all_workers_alive?
+        !!workers.all? { |t| t&.alive? }
+      end
+
+      def boot_worker
+        debug '%s: Booting worker...', pid_str
+
+        Thread.new do
+          Worker.new(
+            config, queue,
+            serializers: @serializers,
+            filters: @filters
+          ).work_forever
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def stop_workers
+        debug '%s: Stopping workers', pid_str
+
+        send_stop_messages
+
+        @worker_mutex.synchronize do
+          workers.each do |thread|
+            next if thread.nil?
+            next if thread.join(WORKER_JOIN_TIMEOUT)
+
+            debug(
+              '%s: Worker did not stop in %ds, killing...',
+              pid_str, WORKER_JOIN_TIMEOUT
+            )
+            thread.kill
+          end
+
+          @workers.clear
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def send_stop_messages
+        config.pool_size.times { queue.push(Worker::StopMessage.new, true) }
+      rescue ThreadError
+        warn 'Cannot push stop messages to worker queue as it is full'
+      end
+
+      def stop_watcher
+        @watcher_mutex.synchronize do
+          return if watcher.nil? || @pid != Process.pid
+          watcher.shutdown
+        end
+      end
+
+      def throttled_queue_full_warning
+        (@queue_full_log ||= Util::Throttle.new(5) do
+          warn(
+            '%s: Queue is full (%i items), skipping…',
+            pid_str, config.api_buffer_size
+          )
+        end).call
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/atatus/transport/connection.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'zlib'
+
+require 'atatus/transport/connection/http'
+
+module Atatus
+  module Transport
+    # rubocop:disable Metrics/ClassLength
+    # @api private
+    class Connection
+      include Logging
+
+      # A connection holds an instance `http` of an Http::Connection.
+      #
+      # The HTTP::Connection itself is not thread safe.
+      #
+      # The connection sends write requests and close requests to `http`, and
+      # has to ensure no write requests are sent after closing `http`.
+      #
+      # The connection schedules a separate thread to close an `http`
+      # connection some time in the future. To avoid the thread interfering
+      # with ongoing write requests to `http`, write and close
+      # requests have to be synchronized.
+
+      HEADERS = {
+        'Content-Type' => 'application/x-ndjson',
+        'Transfer-Encoding' => 'chunked'
+      }.freeze
+      GZIP_HEADERS = HEADERS.merge(
+        'Content-Encoding' => 'gzip'
+      ).freeze
+
+      def initialize(config, metadata)
+        @config = config
+        @headers = build_headers(metadata)
+        @metadata = JSON.fast_generate(metadata)
+        @url = config.server_url + '/intake/v2/events'
+        @ssl_context = build_ssl_context
+        @mutex = Mutex.new
+      end
+
+      attr_reader :http
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def write(str)
+        return false if @config.disable_send
+
+        begin
+          bytes_written = 0
+
+          # The request might get closed from timertask so let's make sure we
+          # hold it open until we've written.
+          @mutex.synchronize do
+            connect if http.nil? || http.closed?
+            bytes_written = http.write(str)
+          end
+
+          flush(:api_request_size) if bytes_written >= @config.api_request_size
+        rescue IOError => e
+          error('Connection error: %s', e.inspect)
+          flush(:ioerror)
+        rescue Errno::EPIPE => e
+          error('Connection error: %s', e.inspect)
+          flush(:broken_pipe)
+        rescue Exception => e
+          error('Connection error: %s', e.inspect)
+          flush(:connection_error)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def flush(reason = :force)
+        # Could happen from the timertask so we need to sync
+        @mutex.synchronize do
+          return if http.nil?
+          http.close(reason)
+        end
+      end
+
+      def inspect
+        format(
+          '@%s http connection closed? :%s>',
+          super.split.first,
+          http.closed?
+        )
+      end
+
+      private
+
+      def connect
+        schedule_closing if @config.api_request_time
+
+        @http =
+          Http.open(
+            @config, @url,
+            headers: @headers,
+            ssl_context: @ssl_context
+          ).tap { |http| http.write(@metadata) }
+      end
+      # rubocop:enable
+
+      def schedule_closing
+        @close_task&.cancel
+        @close_task =
+          Concurrent::ScheduledTask.execute(@config.api_request_time) do
+            flush(:timeout)
+          end
+      end
+
+      def build_headers(metadata)
+        (
+          @config.http_compression? ? GZIP_HEADERS : HEADERS
+        ).dup.tap do |headers|
+          headers['User-Agent'] = build_user_agent(metadata)
+
+          if (token = @config.secret_token)
+            headers['Authorization'] = "Bearer #{token}"
+          end
+        end
+      end
+
+      def build_user_agent(metadata)
+        runtime = metadata.dig(:metadata, :service, :runtime)
+
+        [
+          "atatus-ruby/#{VERSION}",
+          HTTP::Request::USER_AGENT,
+          [runtime[:name], runtime[:version]].join('/')
+        ].join(' ')
+      end
+
+      def build_ssl_context # rubocop:disable Metrics/MethodLength
+        return unless @config.use_ssl?
+
+        OpenSSL::SSL::SSLContext.new.tap do |context|
+          if @config.server_ca_cert
+            context.ca_file = @config.server_ca_cert
+          else
+            context.cert_store =
+              OpenSSL::X509::Store.new.tap(&:set_default_paths)
+          end
+
+          context.verify_mode =
+            if @config.verify_server_cert
+              OpenSSL::SSL::VERIFY_PEER
+            else
+              OpenSSL::SSL::VERIFY_NONE
+            end
+        end
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end