atatus 1.0.0

data/lib/atatus/transport/serializers/error_serializer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Serializers
+      # @api private
+      class ErrorSerializer < Serializer
+        def context_serializer
+          @context_serializer ||= ContextSerializer.new(config)
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def build(error)
+          base = {
+            id: error.id,
+            transaction_id: error.transaction_id,
+            transaction: build_transaction(error.transaction),
+            trace_id: error.trace_id,
+            parent_id: error.parent_id,
+
+            culprit: keyword_field(error.culprit),
+            timestamp: error.timestamp
+          }
+
+          if (context = context_serializer.build(error.context))
+            base[:context] = context
+          end
+
+          if (exception = error.exception)
+            base[:exception] = build_exception exception
+          end
+
+          if (log = error.log)
+            base[:log] = build_log log
+          end
+
+          { error: base }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        private
+
+        def build_exception(exception)
+          {
+            message: exception.message,
+            type: keyword_field(exception.type),
+            module: keyword_field(exception.module),
+            code: keyword_field(exception.code),
+            attributes: exception.attributes,
+            stacktrace: exception.stacktrace.to_a,
+            handled: exception.handled,
+            cause: exception.cause && [build_exception(exception.cause)]
+          }
+        end
+
+        def build_log(log)
+          {
+            message: log.message,
+            level: keyword_field(log.level),
+            logger_name: keyword_field(log.logger_name),
+            param_message: keyword_field(log.param_message),
+            stacktrace: log.stacktrace.to_a
+          }
+        end
+
+        def build_transaction(transaction)
+          return unless transaction
+
+          {
+            sampled: transaction[:sampled],
+            type: keyword_field(transaction[:type])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/serializers/metadata_serializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Serializers
+      # @api private
+      class MetadataSerializer < Serializer
+        def build(metadata)
+          {
+            metadata: {
+              service: build_service(metadata.service),
+              process: build_process(metadata.process),
+              system: build_system(metadata.system),
+              labels: build_labels(metadata.labels)
+            }
+          }
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def build_service(service)
+          {
+            name: keyword_field(service.name),
+            environment: keyword_field(service.environment),
+            version: keyword_field(service.version),
+            agent: {
+              name: keyword_field(service.agent.name),
+              version: keyword_field(service.agent.version)
+            },
+            framework: {
+              name: keyword_field(service.framework.name),
+              version: keyword_field(service.framework.version)
+            },
+            language: {
+              name: keyword_field(service.language.name),
+              version: keyword_field(service.language.version)
+            },
+            runtime: {
+              name: keyword_field(service.runtime.name),
+              version: keyword_field(service.runtime.version)
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        def build_process(process)
+          {
+            pid: process.pid,
+            title: keyword_field(process.title),
+            argv: process.argv
+          }
+        end
+
+        def build_system(system)
+          {
+            hostname: keyword_field(system.hostname),
+            architecture: keyword_field(system.architecture),
+            platform: keyword_field(system.platform),
+            kubernetes: keyword_object(system.kubernetes)
+          }
+        end
+
+        def build_labels(labels)
+          keyword_object(labels)
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/serializers/metricset_serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Serializers
+      # @api private
+      class MetricsetSerializer < Serializer
+        def build(metricset)
+          {
+            metricset: {
+              timestamp: metricset.timestamp.to_i,
+              tags: keyword_object(metricset.labels),
+              samples: build_samples(metricset.samples)
+            }
+          }
+        end
+
+        private
+
+        def build_samples(samples)
+          samples.each_with_object({}) do |(key, value), hsh|
+            hsh[key] = { value: value }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/serializers/span_serializer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Serializers
+      # @api private
+      class SpanSerializer < Serializer
+        def initialize(config)
+          super
+
+          @context_serializer = ContextSerializer.new(config)
+        end
+
+        attr_reader :context_serializer
+
+        # rubocop:disable Metrics/MethodLength
+        def build(span)
+          {
+            span: {
+              id: span.id,
+              transaction_id: span.transaction_id,
+              parent_id: span.parent_id,
+              name: keyword_field(span.name),
+              type: join_type(span),
+              duration: ms(span.duration),
+              context: context_serializer.build(span.context),
+              stacktrace: span.stacktrace.to_a,
+              timestamp: span.timestamp,
+              trace_id: span.trace_id
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # @api private
+        class ContextSerializer < Serializer
+          def build(context)
+            return unless context
+
+            { sync: context.sync }.tap do |base|
+              base[:db] = build_db(context.db) if context.db
+              base[:http] = build_http(context.http) if context.http
+            end
+          end
+
+          private
+
+          def build_db(db)
+            return unless db
+
+            {
+              instance: db.instance,
+              statement: Util.truncate(db.statement, max_length: 10_000),
+              type: db.type,
+              user: db.user
+            }
+          end
+
+          def build_http(http)
+            return unless http
+
+            {
+              url: http.url,
+              status_code: http.status_code.to_i,
+              method: keyword_field(http.method)
+            }
+          end
+        end
+
+        private
+
+        def join_type(span)
+          combined = [span.type, span.subtype, span.action]
+          combined.compact!
+          combined.join '.'
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/serializers/transaction_serializer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Serializers
+      # @api private
+      class TransactionSerializer < Serializer
+        def context_serializer
+          @context_serializer ||= ContextSerializer.new(config)
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def build(transaction)
+          {
+            transaction: {
+              id: transaction.id,
+              trace_id: transaction.trace_id,
+              parent_id: transaction.parent_id,
+              name: keyword_field(transaction.name),
+              type: keyword_field(transaction.type),
+              result: keyword_field(transaction.result.to_s),
+              duration: ms(transaction.duration),
+              timestamp: transaction.timestamp,
+              sampled: transaction.sampled?,
+              context: context_serializer.build(transaction.context),
+              span_count: {
+                started: transaction.started_spans,
+                dropped: transaction.dropped_spans
+              }
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/atatus/transport/worker.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    # @api private
+    class Worker
+      include Logging
+
+      # @api private
+      class StopMessage; end
+
+      # @api private
+      class FlushMessage; end
+
+      def initialize(
+        config,
+        queue,
+        serializers:,
+        filters:,
+        conn_adapter: Connection
+      )
+        @config = config
+        @queue = queue
+
+        @serializers = serializers
+        @filters = filters
+
+        metadata = serializers.serialize(Metadata.new(config))
+        @connection = conn_adapter.new(config, metadata)
+      end
+
+      attr_reader :queue, :filters, :name, :connection, :serializers
+
+      # rubocop:disable Metrics/MethodLength
+      def work_forever
+        while (msg = queue.pop)
+          case msg
+          when StopMessage
+            debug 'Stopping worker -- %s', self
+            connection.flush(:halt)
+            break
+          else
+            process msg
+          end
+        end
+      rescue Exception => e
+        warn 'Worker died with exception: %s', e.inspect
+        debug e.backtrace.join("\n")
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def process(resource)
+        return unless (json = serialize_and_filter(resource))
+        connection.write(json)
+      end
+
+      private
+
+      def serialize_and_filter(resource)
+        serialized = serializers.serialize(resource)
+
+        # if a filter returns nil, it means skip the event
+        return nil if @filters.apply!(serialized) == Filters::SKIP
+
+        JSON.fast_generate(serialized)
+      rescue Exception
+        error format('Failed converting event to JSON: %s', resource.inspect)
+        error serialized.inspect
+        nil
+      end
+    end
+  end
+end

data/lib/atatus/util.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Util
+
+    def self.ms(micros)
+      micros.to_f / 1_000
+    end
+
+    def self.micros(target = Time.now)
+      utc = target.utc
+      utc.to_i * 1_000_000 + utc.usec
+    end
+
+    def self.monotonic_micros
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+    end
+
+    def self.git_sha
+      sha = `git rev-parse --verify HEAD 2>&1`.chomp
+      $? && $?.success? ? sha : nil
+    end
+
+    def self.hex_to_bits(str)
+      str.hex.to_s(2).rjust(str.size * 4, '0')
+    end
+
+    def self.reverse_merge!(first, *others)
+      others.reduce(first) do |curr, other|
+        curr.merge!(other) { |_, _, new| new }
+      end
+    end
+
+    def self.truncate(value, max_length: 1024)
+      return unless value
+      return value if value.length <= max_length
+
+      value[0...(max_length - 1)] + '…'
+    end
+  end
+end

data/lib/atatus/util/inflector.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Atatus
+  # rubocop:disable all
+  module Util
+    # From https://github.com/rails/rails/blob/v5.2.0/activesupport/lib/active_support/inflector/methods.rb#L254-L332
+    module Inflector
+      extend self
+
+      #
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   constantize('Module')   # => Module
+      #   constantize('Foo::Bar') # => Foo::Bar
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                # => 'inside'
+      #     constantize('C') # => 'outside', same as ::C
+      #   end
+      #
+      # NameError is raised when the name is not in CamelCase or the constant is
+      # unknown.
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split("::".freeze)
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject(constant) do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   safe_constantize('Module')   # => Module
+      #   safe_constantize('Foo::Bar') # => Foo::Bar
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                     # => 'inside'
+      #     safe_constantize('C') # => 'outside', same as ::C
+      #   end
+      #
+      # +nil+ is returned when the name is not in CamelCase or the constant (or
+      # part of it) is unknown.
+      #
+      #   safe_constantize('blargle')                  # => nil
+      #   safe_constantize('UnknownModule')            # => nil
+      #   safe_constantize('UnknownModule::Foo::Bar')  # => nil
+      def safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+                             e.name.to_s == camel_cased_word.to_s)
+      rescue ArgumentError => e
+        raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match(e.message)
+      end
+    end
+  end
+  # rubocop:enable all
+end