atatus 1.0.0

data/lib/atatus/transport/connection/http.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'http'
+require 'concurrent'
+require 'zlib'
+
+require 'atatus/transport/connection/proxy_pipe'
+
+module Atatus
+  module Transport
+    class Connection
+      # @api private
+      class Http
+        include Logging
+
+        def initialize(config)
+          @config = config
+          @closed = Concurrent::AtomicBoolean.new
+
+          @rd, @wr = ProxyPipe.pipe(compress: @config.http_compression?)
+        end
+
+        def open(url, headers: {}, ssl_context: nil)
+          @request = open_request_in_thread(url, headers, ssl_context)
+        end
+
+        def self.open(config, url, headers: {}, ssl_context: nil)
+          new(config).tap do |http|
+            http.open(url, headers: headers, ssl_context: ssl_context)
+          end
+        end
+
+        def write(str)
+          @wr.write(str)
+          @wr.bytes_sent
+        end
+
+        def close(reason)
+          return if closed?
+
+          debug '%s: Closing request with reason %s', thread_str, reason
+          @closed.make_true
+
+          @wr&.close(reason)
+          return if @request.nil? || @request&.join(5)
+
+          error(
+            '%s: APM Server not responding in time, terminating request',
+            thread_str
+          )
+          @request.kill
+        end
+
+        def closed?
+          @closed.true?
+        end
+
+        def inspect
+          format(
+            '%s closed: %s>',
+            super.split.first,
+            closed?
+          )
+        end
+
+        private
+
+        def thread_str
+          format('[THREAD:%s]', Thread.current.object_id)
+        end
+
+        # rubocop:disable Metrics/LineLength
+        def open_request_in_thread(url, headers, ssl_context)
+          client = build_client(headers)
+
+          debug '%s: Opening new request', thread_str
+          Thread.new do
+            begin
+              post(client, url, ssl_context)
+            rescue Exception => e
+              error "Couldn't establish connection to APM Server:\n%p", e.inspect
+            end
+          end
+        end
+        # rubocop:enable Metrics/LineLength
+
+        def build_client(headers)
+          client = HTTP.headers(headers)
+          return client unless @config.proxy_address && @config.proxy_port
+
+          client.via(
+            @config.proxy_address,
+            @config.proxy_port,
+            @config.proxy_username,
+            @config.proxy_password,
+            @config.proxy_headers
+          )
+        end
+
+        def post(client, url, ssl_context)
+          resp = client.post(
+            url,
+            body: @rd,
+            ssl_context: ssl_context
+          ).flush
+
+          if resp&.status == 202
+            debug 'APM Server responded with status 202'
+          elsif resp
+            error "APM Server responded with an error:\n%p", resp.body.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/connection/proxy_pipe.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'zlib'
+
+module Atatus
+  module Transport
+    class Connection
+      # @api private
+      class ProxyPipe
+        def initialize(enc = nil, compress: true)
+          rd, wr = IO.pipe(enc)
+
+          @read = rd
+          @write = Write.new(wr, compress: compress)
+
+          # Http.rb<4 calls rewind on the request bodies, but IO::Pipe raises
+          # ~mikker
+          return if HTTP::VERSION.to_i >= 4
+          def rd.rewind; end
+        end
+
+        attr_reader :read, :write
+
+        # @api private
+        class Write
+          include Logging
+
+          def initialize(io, compress: true)
+            @io = io
+            @compress = compress
+            @bytes_sent = Concurrent::AtomicFixnum.new(0)
+            @config = Atatus.agent&.config # this is silly, fix Logging
+
+            return unless compress
+            enable_compression!
+          end
+
+          attr_reader :io
+
+          def enable_compression!
+            io.binmode
+            @io = Zlib::GzipWriter.new(io)
+          end
+
+          def close(reason = nil)
+            debug("Closing writer with reason #{reason}")
+            io.close
+          end
+
+          def closed?
+            io.closed?
+          end
+
+          def write(str)
+            io.puts(str).tap do
+              @bytes_sent.update do |curr|
+                @compress ? io.tell : curr + str.bytesize
+              end
+            end
+          end
+
+          def bytes_sent
+            @bytes_sent.value
+          end
+        end
+
+        def self.pipe(*args)
+          pipe = new(*args)
+          [pipe.read, pipe.write]
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/filters.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'atatus/transport/filters/secrets_filter'
+
+module Atatus
+  module Transport
+    # @api private
+    module Filters
+      SKIP = :skip
+
+      def self.new(config)
+        Container.new(config)
+      end
+
+      # @api private
+      class Container
+        def initialize(config)
+          @filters = { secrets: SecretsFilter.new(config) }
+        end
+
+        def add(key, filter)
+          @filters[key] = filter
+        end
+
+        def remove(key)
+          @filters.delete(key)
+        end
+
+        def apply!(payload)
+          @filters.reduce(payload) do |result, (_key, filter)|
+            result = filter.call(result)
+            break SKIP if result.nil?
+            result
+          end
+        end
+
+        def length
+          @filters.length
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/filters/secrets_filter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Filters
+      # @api private
+      class SecretsFilter
+        FILTERED = '[FILTERED]'
+
+        KEY_FILTERS = [
+          /passw(or)?d/i,
+          /auth/i,
+          /^pw$/,
+          /secret/i,
+          /token/i,
+          /api[-._]?key/i,
+          /session[-._]?id/i,
+          /(set[-_])?cookie/i
+        ].freeze
+
+        VALUE_FILTERS = [
+          # (probably) credit card number
+          /^\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}$/
+        ].freeze
+
+        def initialize(config)
+          @config = config
+          @key_filters = KEY_FILTERS + config.custom_key_filters
+        end
+
+        def call(payload)
+          strip_from! payload.dig(:transaction, :context, :request, :headers)
+          strip_from! payload.dig(:transaction, :context, :request, :env)
+          strip_from! payload.dig(:transaction, :context, :request, :cookies)
+          strip_from! payload.dig(:transaction, :context, :response, :headers)
+          strip_from! payload.dig(:error, :context, :request, :headers)
+          strip_from! payload.dig(:error, :context, :response, :headers)
+          strip_from! payload.dig(:transaction, :context, :request, :body)
+
+          payload
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        def strip_from!(obj)
+          return unless obj && obj.is_a?(Hash)
+
+          obj.each do |k, v|
+            if filter_key?(k)
+              next obj[k] = FILTERED
+            end
+
+            case v
+            when Hash
+              strip_from!(v)
+            when String
+              if filter_value?(v)
+                obj[k] = FILTERED
+              end
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+
+        def filter_key?(key)
+          @key_filters.any? { |regex| key.match regex }
+        end
+
+        def filter_value?(value)
+          VALUE_FILTERS.any? { |regex| value.match regex }
+        end
+      end
+    end
+  end
+end

data/lib/atatus/transport/serializers.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Atatus
+  module Transport
+    # @api private
+    module Serializers
+      # @api private
+      class UnrecognizedResource < InternalError; end
+
+      # @api private
+      class Serializer
+        def initialize(config)
+          @config = config
+        end
+
+        attr_reader :config
+
+        private
+
+        def ms(micros)
+          micros.to_f / 1_000
+        end
+
+        def keyword_field(value)
+          Util.truncate(value)
+        end
+
+        def keyword_object(hash)
+          return unless hash
+
+          hash.tap do |h|
+            h.each { |k, v| hash[k] = keyword_field(v) }
+          end
+        end
+
+        def mixed_object(hash)
+          return unless hash
+
+          hash.tap do |h|
+            h.each do |k, v|
+              hash[k] = v.is_a?(String) ? keyword_field(v) : v
+            end
+          end
+        end
+      end
+
+      # @api private
+      class Container
+        def initialize(config)
+          @transaction = Serializers::TransactionSerializer.new(config)
+          @span = Serializers::SpanSerializer.new(config)
+          @error = Serializers::ErrorSerializer.new(config)
+          @metadata = Serializers::MetadataSerializer.new(config)
+          @metricset = Serializers::MetricsetSerializer.new(config)
+        end
+
+        attr_reader :transaction, :span, :error, :metadata, :metricset
+
+        # rubocop:disable Metrics/MethodLength
+        def serialize(resource)
+          case resource
+          when Transaction
+            transaction.build(resource)
+          when Span
+            span.build(resource)
+          when Error
+            error.build(resource)
+          when Metricset
+            metricset.build(resource)
+          when Metadata
+            metadata.build(resource)
+          else
+            raise UnrecognizedResource, resource.inspect
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      def self.new(config)
+        Container.new(config)
+      end
+    end
+  end
+end
+
+require 'atatus/transport/serializers/context_serializer'
+require 'atatus/transport/serializers/transaction_serializer'
+require 'atatus/transport/serializers/span_serializer'
+require 'atatus/transport/serializers/error_serializer'
+require 'atatus/transport/serializers/metricset_serializer'
+require 'atatus/transport/serializers/metadata_serializer'

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Transport
+    module Serializers
+      # @api private
+      class ContextSerializer < Serializer
+        def build(context)
+          return nil if context.nil? || context.empty?
+
+          {
+            custom: context.custom,
+            tags: mixed_object(context.labels),
+            request: build_request(context.request),
+            response: build_response(context.response),
+            user: build_user(context.user)
+          }
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def build_request(request)
+          return unless request
+
+          {
+            body: request.body,
+            cookies: request.cookies,
+            env: request.env,
+            headers: request.headers,
+            http_version: keyword_field(request.http_version),
+            method: keyword_field(request.method),
+            socket: build_socket(request.socket),
+            url: build_url(request.url)
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def build_response(response)
+          return unless response
+
+          {
+            status_code: response.status_code.to_i,
+            headers: response.headers,
+            headers_sent: response.headers_sent,
+            finished: response.finished
+          }
+        end
+
+        def build_user(user)
+          return if !user || user.empty?
+
+          {
+            id: keyword_field(user.id),
+            email: keyword_field(user.email),
+            username: keyword_field(user.username)
+          }
+        end
+
+        def build_socket(socket)
+          return unless socket
+
+          {
+            remote_addr: socket.remote_addr,
+            encrypted: socket.encrypted
+          }
+        end
+
+        def build_url(url)
+          return unless url
+
+          {
+            protocol: keyword_field(url.protocol),
+            full: keyword_field(url.full),
+            hostname: keyword_field(url.hostname),
+            port: keyword_field(url.port),
+            pathname: keyword_field(url.pathname),
+            search: keyword_field(url.search),
+            hash: keyword_field(url.hash)
+          }
+        end
+      end
+    end
+  end
+end