atatus 1.3.0 → 1.6.1

data/lib/atatus/trace_context/tracestate.rb

@@ -0,0 +1,148 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# frozen_string_literal: true
+
+module Atatus
+  class TraceContext
+    # @api private
+    class Tracestate
+      # @api private
+      class Entry
+        def initialize(key, value)
+          @key = key
+          @value = value
+        end
+
+        attr_reader :key, :value
+
+        def to_s
+          "#{key}=#{value}"
+        end
+      end
+
+      class EsEntry
+        ASSIGN = ':'
+        SPLIT = ';'
+
+        SHORT_TO_LONG = { 's' => 'sample_rate' }
+        LONG_TO_SHORT = { 'sample_rate' => 's' }
+
+        def initialize(values = nil)
+          parse(values)
+        end
+
+        attr_reader :sample_rate
+
+        def key
+          'es'
+        end
+
+        def value
+          LONG_TO_SHORT.map do |l, s|
+            "#{s}#{ASSIGN}#{send(l)}"
+          end.join(SPLIT)
+        end
+
+        def empty?
+          !sample_rate
+        end
+
+        def sample_rate=(val)
+          float = Float(val).round(3)
+
+          return nil unless (0.0..1.0).include?(float)
+
+          @sample_rate = float
+        rescue ArgumentError => e
+          nil
+        end
+
+        def to_s
+          return nil if empty?
+
+          "es=#{value}"
+        end
+
+        private
+
+        def parse(values)
+          return unless values
+
+          values.split(SPLIT).map do |kv|
+            k, v = kv.split(ASSIGN)
+            next unless SHORT_TO_LONG.keys.include?(k)
+            send("#{SHORT_TO_LONG[k]}=", v)
+          end
+        end
+      end
+
+      extend Forwardable
+
+      def initialize(entries: {}, sample_rate: nil)
+        @entries = entries
+
+        self.sample_rate = sample_rate if sample_rate
+      end
+
+      attr_accessor :entries
+
+      def_delegators :es_entry, :sample_rate, :sample_rate=
+
+      def self.parse(header)
+        entries =
+          split_by_nl_and_comma(header)
+          .each_with_object({}) do |entry, hsh|
+            k, v = entry.split('=')
+
+            hsh[k] =
+              case k
+              when 'es' then EsEntry.new(v)
+              else Entry.new(k, v)
+              end
+          end
+
+        new(entries: entries)
+      end
+
+      def to_header
+        return "" unless entries.any?
+
+        entries.values.map(&:to_s).join(',')
+      end
+
+      private
+
+      def es_entry
+        # lazy generate this so we only add it if necessary
+        entries['es'] ||= EsEntry.new
+      end
+
+      class << self
+        private
+
+        def split_by_nl_and_comma(str)
+          # HTTP allows multiple headers with the same name, eg. multiple
+          # Set-Cookie headers per response.
+          # Rack handles this by joining the headers under the same key, separated
+          # by newlines, see https://www.rubydoc.info/github/rack/rack/file/SPEC
+          String(str).split("\n").map { |s| s.split(',') }.flatten
+        end
+      end
+    end
+  end
+end

data/lib/atatus/trace_context.rb

@@ -1,85 +1,118 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
 # frozen_string_literal: true
 
+require 'atatus/trace_context/tracestate'
+require 'atatus/trace_context/traceparent'
+
 module Atatus
   # @api private
   class TraceContext
-    class InvalidTraceparentHeader < StandardError; end
+    extend Forwardable
 
-    VERSION = '00'
-    HEX_REGEX = /[^[:xdigit:]]/.freeze
-
-    TRACE_ID_LENGTH = 16
-    ID_LENGTH = 8
+    class InvalidTraceparentHeader < StandardError; end
 
     def initialize(
-      version: VERSION,
-      trace_id: nil,
-      span_id: nil,
-      id: nil,
-      recorded: true
+      traceparent: nil,
+      tracestate: nil,
+      **legacy_traceparent_attrs
     )
-      @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
+      @traceparent = traceparent || Traceparent.new(**legacy_traceparent_attrs)
+      @tracestate = tracestate || Tracestate.new
     end
 
-    attr_accessor :version, :id, :trace_id, :parent_id, :recorded
+    attr_accessor :traceparent, :tracestate
+
+    def_delegators :traceparent,
+      :version, :trace_id, :id, :parent_id, :ensure_parent_id, :recorded?
+
+    class << self
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def parse(legacy_header = nil, env: nil, metadata: nil)
+        unless legacy_header || env || metadata
+          raise ArgumentError, 'TraceContext expects env:, metadata: ' \
+            'or single argument header string'
+        end
+
+        if legacy_header
+          legacy_parse_from_header(legacy_header)
+        elsif env
+          trace_context_from_env(env)
+        elsif metadata
+          trace_context_from_metadata(metadata)
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      private
 
-    alias :recorded? :recorded
+      def trace_context_from_env(env)
+        return unless (
+          header =
+            env['HTTP_ATATUS_TRACEPARENT'] || env['HTTP_TRACEPARENT']
+        )
 
-    # rubocop:disable Metrics/AbcSize
-    def self.parse(header)
-      raise InvalidTraceparentHeader unless header.length == 55
-      raise InvalidTraceparentHeader unless header[0..1] == VERSION
+        parent = TraceContext::Traceparent.parse(header)
 
-      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])
+        state =
+          if (header = env['HTTP_TRACESTATE'])
+            TraceContext::Tracestate.parse(header)
           end
 
-        raise InvalidTraceparentHeader if HEX_REGEX =~ t.trace_id
-        raise InvalidTraceparentHeader if HEX_REGEX =~ t.parent_id
+        new(traceparent: parent, tracestate: state)
       end
-    end
-    # rubocop:enable Metrics/AbcSize
 
-    def flags=(flags)
-      @flags = flags
+      def trace_context_from_metadata(metadata)
+        return unless (header = metadata['atatus-traceparent'] ||
+          metadata['traceparent'])
 
-      self.recorded = flags[7] == '1'
-    end
+        parent = TraceContext::Traceparent.parse(header)
 
-    def flags
-      format('0000000%d', recorded? ? 1 : 0)
-    end
+        state =
+          if (header = metadata['tracestate'])
+            TraceContext::Tracestate.parse(header)
+          end
 
-    def hex_flags
-      format('%02x', flags.to_i(2))
-    end
+        new(traceparent: parent, tracestate: state)
+      end
 
-    def ensure_parent_id
-      @parent_id ||= hex(ID_LENGTH)
+      def legacy_parse_from_header(header)
+        parent = Traceparent.parse(header)
+        new(traceparent: parent)
+      end
     end
 
     def child
       dup.tap do |tc|
-        tc.parent_id = tc.id
-        tc.id = hex(ID_LENGTH)
+        tc.traceparent = tc.traceparent.child
       end
     end
 
-    def to_header
-      format('%s-%s-%s-%s', version, trace_id, id, hex_flags)
-    end
+    def apply_headers
+      yield 'Traceparent', traceparent.to_header
+
+      if tracestate
+        yield 'Tracestate', tracestate.to_header
+      end
 
-    private
+      return unless Atatus.agent.config.use_atatus_traceparent_header
 
-    def hex(len)
-      SecureRandom.hex(len)
+      yield 'Atatus-Traceparent', traceparent.to_header
     end
   end
 end

data/lib/atatus/transaction.rb

@@ -1,36 +1,71 @@
-# frozen_string_literal: true
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
 
-require 'securerandom'
-require 'forwardable'
+# frozen_string_literal: true
 
 module Atatus
   # @api private
   class Transaction
     extend Forwardable
+    include ChildDurations::Methods
 
     def_delegators :@trace_context,
       :trace_id, :parent_id, :id, :ensure_parent_id
 
     DEFAULT_TYPE = 'custom'
+    MUTEX = Mutex.new
 
     # rubocop:disable Metrics/ParameterLists
     def initialize(
       name = nil,
       type = nil,
       sampled: true,
+      sample_rate: 1,
       context: nil,
-      labels: nil,
+      config:,
       trace_context: nil
     )
       @name = name
       @type = type || DEFAULT_TYPE
+      @config = config
+
+      # Cache these values in case they are changed during the
+      # transaction's lifetime via the remote config
+      @span_frames_min_duration = config.span_frames_min_duration
+      @collect_metrics = config.collect_metrics?
+      @breakdown_metrics = config.breakdown_metrics?
+      @framework_name = config.framework_name
+      @transaction_max_spans = config.transaction_max_spans
+      @default_labels = config.default_labels
 
       @sampled = sampled
+      @sample_rate = sample_rate
 
       @context = context || Context.new # TODO: Lazy generate this?
-      Util.reverse_merge!(@context.labels, labels) if labels
+      if @default_labels
+        Util.reverse_merge!(@context.labels, @default_labels)
+      end
 
-      @trace_context = trace_context || TraceContext.new(recorded: sampled)
+      unless (@trace_context = trace_context)
+        @trace_context = TraceContext.new(
+          traceparent: TraceContext::Traceparent.new(recorded: sampled),
+          tracestate: TraceContext::Tracestate.new(sample_rate: sampled ? sample_rate : 0)
+        )
+      end
 
       @started_spans = 0
       @dropped_spans = 0
@@ -41,8 +76,24 @@ module Atatus
 
     attr_accessor :name, :type, :result, :spans, :ruby_time
 
-    attr_reader :context, :duration, :started_spans, :dropped_spans,
-      :timestamp, :trace_context, :notifications
+    attr_reader(
+      :breakdown_metrics,
+      :collect_metrics,
+      :context,
+      :dropped_spans,
+      :duration,
+      :framework_name,
+      :notifications,
+      :self_time,
+      :sample_rate,
+      :span_frames_min_duration,
+      :started_spans,
+      :timestamp,
+      :trace_context,
+      :transaction_max_spans 
+    )
+
+    alias :collect_metrics? :collect_metrics
 
     def sampled?
       @sampled
@@ -63,6 +114,8 @@ module Atatus
     def stop(clock_end = Util.monotonic_micros)
       raise 'Transaction not yet start' unless timestamp
       @duration = clock_end - @clock_start
+      @self_time = @duration - child_durations.duration
+
       self
     end
 
@@ -75,21 +128,24 @@ module Atatus
     # spans
 
     def inc_started_spans!
-      @started_spans += 1
+      MUTEX.synchronize do
+        @started_spans += 1
+        if @started_spans > transaction_max_spans
+          @dropped_spans += 1
+          return false
+        end
+      end
+      true
     end
 
-    def inc_dropped_spans!
-      @dropped_spans += 1
-    end
+    # context
 
-    def max_spans_reached?(config)
-      started_spans > config.transaction_max_spans
+    def add_response(status = nil, **args)
+      context.response = Context::Response.new(status, **args)
     end
 
-    # context
-
-    def add_response(*args)
-      context.response = Context::Response.new(*args)
+    def set_user(user)
+      context.user = Context::User.infer(@config, user)
     end
 
     def inspect

data/lib/atatus/transport/base.rb

@@ -1,15 +1,35 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
 # frozen_string_literal: true
 
 require 'atatus/metadata'
+require 'atatus/transport/user_agent'
+require 'atatus/transport/headers'
 require 'atatus/transport/connection'
 require 'atatus/transport/worker'
 require 'atatus/transport/serializers'
 require 'atatus/transport/filters'
+require 'atatus/transport/connection/http'
+
 require 'atatus/util/throttle'
 
 module Atatus
   module Transport
-    # rubocop:disable Metrics/ClassLength
     # @api private
     class Base
       include Logging
@@ -28,7 +48,6 @@ module Atatus
         @stopped = Concurrent::AtomicBoolean.new
         @workers = Array.new(config.pool_size)
 
-        @watcher_mutex = Mutex.new
         @worker_mutex = Mutex.new
       end
 
@@ -36,9 +55,13 @@ module Atatus
 
       def start
         debug '%s: Starting Transport', pid_str
+        # Set @stopped to false first, in case transport is restarted;
+        # ensure_worker_count requires @stopped to be false
+        # ~estolfo
+        @stopped.make_false unless @stopped.false?
 
-        ensure_watcher_running
         ensure_worker_count
+        create_watcher
       end
 
       def stop
@@ -50,14 +73,13 @@ module Atatus
         stop_workers
       end
 
-      # rubocop:disable Metrics/MethodLength
       def submit(resource)
         if @stopped.true?
           warn '%s: Transport stopping, no new events accepted', pid_str
+          debug 'Dropping: %s', resource.inspect
           return false
         end
 
-        ensure_watcher_running
         queue.push(resource, true)
 
         true
@@ -68,31 +90,31 @@ module Atatus
         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
 
+      def handle_forking!
+        # We can't just stop and start again because the StopMessage
+        # will then be the first message processed when the transport is
+        # restarted.
+        stop_watcher
+        ensure_worker_count
+        create_watcher
+      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
+      def create_watcher
+        @watcher = Concurrent::TimerTask.execute(
+          execution_interval: WATCHER_EXECUTION_INTERVAL,
+          timeout_interval: WATCHER_TIMEOUT_INTERVAL
+        ) { ensure_worker_count }
       end
 
       def ensure_worker_count
@@ -124,7 +146,6 @@ module Atatus
         end
       end
 
-      # rubocop:disable Metrics/MethodLength
       def stop_workers
         debug '%s: Stopping workers', pid_str
 
@@ -142,10 +163,10 @@ module Atatus
             thread.kill
           end
 
-          @workers.clear
+          # Maintain the @worker array size for when transport is restarted
+          @workers.fill(nil)
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       def send_stop_messages
         config.pool_size.times { queue.push(Worker::StopMessage.new, true) }
@@ -154,10 +175,7 @@ module Atatus
       end
 
       def stop_watcher
-        @watcher_mutex.synchronize do
-          return if watcher.nil? || @pid != Process.pid
-          watcher.shutdown
-        end
+        watcher&.shutdown
       end
 
       def throttled_queue_full_warning
@@ -169,6 +187,5 @@ module Atatus
         end).call
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end