atatus 1.0.0

data/lib/atatus/collector/builder.rb

@@ -0,0 +1,317 @@
+require 'socket'
+require 'atatus/metadata'
+
+module Atatus
+  class Builder
+    AGENT_NAME = 'Ruby'
+
+    def initialize(config)
+      @config = config
+      @metadata = Metadata::SystemInfo.new(config)
+    end
+
+    attr_reader :config
+
+    def common()
+      common = {
+        appName: @config.app_name,
+        licenseKey: @config.license_key,
+        agent: {
+          name: AGENT_NAME,
+          version: VERSION
+        },
+        # tags: @config.default_tags,
+        uniqueHostname: Socket.gethostname,
+        hostname: @metadata.hostname,
+        hostId: @metadata.hwinfo.hostid
+      }
+      unless @metadata.container.nil?
+        common[:containerId] = @metadata.container[:id] if @metadata.container.key?(:id)
+      end
+      common
+    end
+
+    def txns(start_time, end_time, data)
+      payload = common()
+      payload[:startTime] = (start_time.to_f * 1000).to_i
+      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:transactions] = build_txns_obj(data)
+      payload
+    end
+
+    def traces(start_time, end_time, data)
+      payload = common()
+      payload[:startTime] = (start_time.to_f * 1000).to_i
+      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:traces] = build_traces_obj(data)
+      payload
+    end
+
+    def error_metrics(start_time, end_time, metrics_data, requests_data)
+      payload = common()
+      payload[:startTime] = (start_time.to_f * 1000).to_i
+      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:errorMetrics] = build_error_metrics_obj(metrics_data)
+      payload[:errorRequests] = build_error_requests_obj(requests_data)
+      payload
+    end
+
+    def hostinfo(start_time)
+      payload = common()
+      payload[:timestamp] = (start_time.to_f * 1000).to_i
+      payload[:environment] = build_hostinfo_obj()
+      payload
+    end
+
+    def errors(start_time, end_time, error_data)
+      payload = common()
+      payload[:errors] = build_errors_obj(error_data)
+      payload
+    end
+
+    def metrics(start_time, end_time, metric_data)
+      payload = common()
+      payload[:startTime] = (start_time.to_f * 1000).to_i
+      payload[:endTime] = (end_time.to_f * 1000).to_i
+      payload[:ruby] = metric_data
+      payload
+    end
+
+    private
+
+    def keyword_field(value)
+      Util.truncate(value)
+    end
+
+    def build_request(context)
+      return unless context
+      return unless context.request
+
+      request = {
+        accept: context.request.headers['Accept'],
+        'accept-encoding': context.request.headers['Accept-Encoding'],
+        'accept-language': context.request.headers['Accept-Language'],
+        host: context.request.url.hostname,
+        port: (context.request.url.port).to_i,
+        method: context.request.method,
+        userAgent: context.request.headers['User-Agent'],
+        path: context.request.url.pathname
+      }
+      unless context.response.nil?
+        unless context.response.status_code.nil?
+          request[:statusCode] = context.response.status_code
+        end
+      end
+      request
+    end
+
+    def build_error_requests_obj(requests_data)
+      error_requests = []
+      requests_data.each do |v|
+        error_request = {}
+        error_request[:name] = v['name']
+        error_request[:type] = @config.framework_name
+        error_request[:kind] = "Ruby"
+        error_request[:request] = build_request(v['context'])
+        error_requests << error_request
+      end
+      error_requests
+    end
+
+    def build_errors_obj(data)
+      errors = []
+      data.each do |v|
+        error = {}
+        error[:timestamp] = v.timestamp
+        unless v.transaction.nil?
+          error[:transaction] = v.transaction[:name] if v.transaction.key?(:name)
+        end
+        error[:request] = build_request(v.context)
+        error[:exceptions] = []
+        exception = {}
+        exception[:class] = v.exception.type
+        exception[:message] = v.exception.message
+        exception[:stacktrace] = []
+        unless v.exception.stacktrace.nil?
+          unless v.exception.stacktrace.frames.nil?
+            v.exception.stacktrace.frames.each do |f|
+              frame = {}
+              frame[:f] = f.filename
+              frame[:m] = f.function
+              frame[:ln] = f.lineno
+              if f.library_frame == false
+                frame[:inp] = true
+                unless f.context_line.nil?
+                  frame[:code] = []
+
+                  unless f.pre_context.nil?
+                    psize = f.pre_context.size
+                    lineno = 0
+                    if f.lineno - psize >= 0
+                      lineno = f.lineno - psize
+                    end
+                    f.pre_context.each do |c|
+                      frame[:code].push([lineno.to_s, c])
+                      lineno += 1
+                    end
+                  end
+
+                  frame[:code].push([f.lineno.to_s, f.context_line])
+
+                  unless f.post_context.nil?
+                    psize = f.post_context.size
+                    lineno = f.lineno + 1
+                    f.post_context.each do |c|
+                      frame[:code].push([lineno.to_s, c])
+                      lineno += 1
+                    end
+                  end
+                end
+              end
+              exception[:stacktrace] << frame
+            end
+          end
+        end
+        error[:exceptions] << exception
+        errors << error
+      end
+      errors
+    end
+
+    def build_metric(name, value)
+      return unless name
+      return unless value
+
+      {
+        name: name,
+        type: value.type,
+        kind: value.kind,
+        durations: [value.count, Util.ms(value.min), Util.ms(value.max), Util.ms(value.total)]
+      }
+    end
+
+    def build_txns_obj(data)
+      txns = []
+      data.each do |t, v|
+        txn = build_metric(t, v)
+        txn[:traces] = []
+        v.spans.each do |l, u|
+          txn[:traces] << build_metric(l, u)
+        end
+
+        txns << txn
+      end
+      txns
+    end
+
+    def build_traces_obj(data)
+      traces = []
+      data.each do |txn|
+        trace = {}
+        trace[:name] = txn.name
+        trace[:type] = @config.framework_name
+        trace[:kind] = "Ruby"
+        trace[:start] = txn.timestamp
+        trace[:duration] = Util.ms(txn.duration)
+        trace[:request] = build_request(txn.context)
+        trace[:entries] = []
+        trace[:funcs] = []
+        i = 0
+
+        unless txn.spans.nil?
+          unless txn.spans.empty?
+            txn.spans.each do |span|
+              entry = {}
+              entry[:lv] = 1
+              if span.timestamp >= txn.timestamp
+                entry[:so] = Util.ms(span.timestamp - txn.timestamp)
+              else
+                entry[:so] = 0
+              end
+              entry[:du] = Util.ms(span.duration)
+              entry[:ly] = {}
+              entry[:ly][:name] = span.name
+              entry[:ly][:type] = Atatus::Collector::Layer.span_type(span.subtype)
+              entry[:ly][:kind] = Atatus::Collector::Layer.span_kind(span.type)
+              unless span.context.nil?
+                unless span.context.db.nil?
+                  unless span.context.db.statement.nil?
+                    entry[:dt] = {}
+                    entry[:dt][:query] = span.context.db.statement
+                  end
+                end
+              end
+              trace[:entries] << entry
+              func_index = trace[:funcs].index(span.name)
+              if func_index.nil?
+                trace[:funcs] << span.name
+                func_index = i
+                i = i + 1
+              end
+              entry[:i] = func_index
+            end
+          end
+        end
+
+        traces << trace
+      end
+      traces
+    end
+
+    def build_error_metrics_obj(metrics_data)
+      error_metrics = []
+      metrics_data.each do |t, v|
+        error_metric = {}
+        error_metric[:name] = t
+        error_metric[:type] = @config.framework_name
+        error_metric[:kind] = "Ruby"
+        error_metric[:statusCodes] = v
+        error_metrics << error_metric
+      end
+      error_metrics
+    end
+
+    def build_hostinfo_obj()
+      environment = {}
+      environment[:gems] = get_gem_list
+      environment[:host] = build_hostinfo_env_host()
+      environment[:settings] = build_hostinfo_env_settings()
+      environment
+    end
+
+    def build_hostinfo_env_host()
+      host_info = {
+        cpu: [@metadata.hwinfo.cpuinfo],
+        ram: @metadata.hwinfo.meminfo,
+        hostname: @metadata.hostname,
+        uniqueHostname: Socket.gethostname,
+        bootId: @metadata.hwinfo.hostid,
+        hostId: @metadata.hwinfo.hostid,
+        os: @metadata.osinfo.os,
+        kernel: @metadata.osinfo.kernel
+      }
+      unless @metadata.container.nil?
+        host_info[:containerId] = @metadata.container[:id] if @metadata.container.key?(:id)
+      end
+      host_info
+    end
+
+    def build_hostinfo_env_settings()
+      {
+        agentVersion: VERSION,
+        appName: @config.app_name,
+        framework: @config.framework_name,
+        frameworkVersion: @config.framework_version,
+        logLevel: @config.log_level,
+        ruby: RUBY_VERSION
+      }
+    end
+
+    def get_gem_list()
+      Bundler.rubygems.all_specs.map {|spec| [spec.name, spec.version.to_s]}.sort.to_h
+    rescue => e
+      # logger.warn("Couldn't fetch Gem information: #{e.message}")
+      {}
+    end
+  end
+end

data/lib/atatus/collector/transport.rb

@@ -0,0 +1,72 @@
+require 'json'
+require 'thread'
+require 'net/http'
+require 'atatus/collector/builder'
+require 'json'
+
+module Atatus
+  class BaseTransport
+    # include Logging
+
+    TXN_ENDPOINT = '/track/apm/txn'.freeze
+    TRACE_ENDPOINT = '/track/apm/trace'.freeze
+    HOSTINFO_ENDPOINT = "/track/apm/hostinfo".freeze
+    ERROR_ENDPOINT = "/track/apm/error".freeze
+    ERROR_METRIC_ENDPOINT = "/track/apm/error_metric".freeze
+    METRIC_ENDPOINT = "/track/apm/metric".freeze
+
+    def initialize(config, hostname, port)
+      @config = config
+      @hostname = hostname
+      @port = port
+
+      @builder = Atatus::Builder.new(config)
+
+      @headers = {}
+      @headers['Content-Type'] = "application/json"
+    end
+
+    def txn(start_time, end_time, data)
+      payload = @builder.txns(start_time, end_time, data)
+      post(TXN_ENDPOINT, payload)
+    end
+
+    def trace(start_time, end_time, data)
+      payload = @builder.traces(start_time, end_time, data)
+      post(TRACE_ENDPOINT, payload)
+    end
+
+    def error_metrics(start_time, end_time, metrics_data, requests_data)
+      payload = @builder.error_metrics(start_time, end_time, metrics_data, requests_data)
+      post(ERROR_METRIC_ENDPOINT, payload)
+    end
+
+    def hostinfo(start_time)
+      payload = @builder.hostinfo(start_time)
+      post(HOSTINFO_ENDPOINT, payload)
+    end
+
+    def errors(start_time, end_time, error_data)
+      payload = @builder.errors(start_time, end_time, error_data)
+      post(ERROR_ENDPOINT, payload)
+    end
+
+    def metrics(start_time, end_time, metric_data)
+      payload = @builder.metrics(start_time, end_time, metric_data)
+      post(METRIC_ENDPOINT, payload)
+    end
+
+    private
+
+    def post(endpoint, data)
+      request = Net::HTTP::Post.new(endpoint, @headers)
+      request.body = ::JSON.dump(data)
+      http = Net::HTTP.new(@hostname, @port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      response = http.start { |http| http.request(request) }
+    rescue StandardError => e
+      puts "Sending to Atatus backend failed: ", e.inspect, response # To fix
+    end
+  end
+end

data/lib/atatus/config.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'yaml'
+require 'erb'
+
+require 'atatus/util/prefixed_logger'
+
+require 'atatus/config/options'
+require 'atatus/config/duration'
+require 'atatus/config/bytes'
+require 'atatus/config/regexp_list'
+
+module Atatus
+  # rubocop:disable Metrics/ClassLength
+  # @api private
+  class Config
+    extend Options
+
+    DEPRECATED_OPTIONS = %i[].freeze
+
+    # rubocop:disable Metrics/LineLength, Layout/ExtraSpacing
+    option :app_name,                          type: :string
+    option :license_key,                       type: :string
+    option :trace_threshold,                   type: :int,    default: 2000
+    option :config_file,                       type: :string, default: 'config/atatus.yml'
+    option :server_url,                        type: :string, default: 'http://localhost:8200'
+    option :secret_token,                      type: :string
+
+    option :active,                            type: :bool,   default: true
+    option :api_buffer_size,                   type: :int,    default: 256
+    option :api_request_size,                  type: :bytes,  default: '750kb', converter: Bytes.new
+    option :api_request_time,                  type: :float,  default: '10s',   converter: Duration.new
+    option :capture_body,                      type: :string, default: 'off'
+    option :capture_headers,                   type: :bool,   default: true
+    option :capture_env,                       type: :bool,   default: true
+    option :central_config,                    type: :bool,   default: true
+    option :current_user_email_method,         type: :string, default: 'email'
+    option :current_user_id_method,            type: :string, default: 'id'
+    option :current_user_username_method,      type: :string, default: 'username'
+    option :custom_key_filters,                type: :list,   default: [],      converter: RegexpList.new
+    option :default_tags,                      type: :dict,   default: {}
+    option :default_labels,                    type: :dict,   default: {}
+    option :disable_send,                      type: :bool,   default: false
+    option :disable_start_message,             type: :bool,   default: false
+    option :disabled_instrumentations,         type: :list,   default: %w[json]
+    option :disabled_spies,                    type: :list,   default: []
+    option :environment,                       type: :string, default: ENV['RAILS_ENV'] || ENV['RACK_ENV']
+    option :framework_name,                    type: :string
+    option :framework_version,                 type: :string
+    option :filter_exception_types,            type: :list,   default: []
+    option :global_labels,                     type: :dict
+    option :hostname,                          type: :string
+    option :http_compression,                  type: :bool,   default: true
+    option :ignore_url_patterns,               type: :list,   default: [],      converter: RegexpList.new
+    option :instrument,                        type: :bool,   default: true
+    option :instrumented_rake_tasks,           type: :list,   default: []
+    option :log_level,                         type: :int,    default: Logger::INFO
+    option :log_path,                          type: :string, default: '-'
+    option :metrics_interval,                  type: :int,    default: '30s',   converter: Duration.new
+    option :pool_size,                         type: :int,    default: 1
+    option :proxy_address,                     type: :string
+    option :proxy_headers,                     type: :dict
+    option :proxy_password,                    type: :string
+    option :proxy_port,                        type: :int
+    option :proxy_username,                    type: :string
+    option :server_ca_cert,                    type: :string
+    option :service_name,                      type: :string
+    option :service_version,                   type: :string
+    option :source_lines_error_app_frames,     type: :int,    default: 5
+    option :source_lines_error_library_frames, type: :int,    default: 0
+    option :source_lines_span_app_frames,      type: :int,    default: 5
+    option :source_lines_span_library_frames,  type: :int,    default: 0
+    option :span_frames_min_duration,          type: :float,  default: '5ms',   converter: Duration.new(default_unit: 'ms')
+    option :stack_trace_limit,                 type: :int,    default: 999_999
+    option :transaction_max_spans,             type: :int,    default: 500
+    option :transaction_sample_rate,           type: :float,  default: 1.0
+    option :verify_server_cert,                type: :bool,   default: true
+    # rubocop:enable Metrics/LineLength, Layout/ExtraSpacing
+
+    # rubocop:disable Metrics/MethodLength
+    def initialize(options = {})
+      @options = load_schema
+
+      custom_logger = options.delete(:logger)
+
+      assign(options)
+
+      # Pick out config_file specifically as we need it now to load it,
+      # but still need the other env vars to have precedence
+      env = load_env
+      if (env_config_file = env.delete(:config_file))
+        self.config_file = env_config_file
+      end
+
+      assign(load_config_file)
+      assign(env)
+
+      yield self if block_given?
+
+      @logger = custom_logger || build_logger
+
+      @__view_paths = []
+      @__root_path = Dir.pwd
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    attr_accessor :__view_paths, :__root_path
+    attr_accessor :logger
+
+    attr_reader :options
+
+    def assign(update)
+      return unless update
+      update.each { |key, value| send(:"#{key}=", value) }
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def available_instrumentations
+      %w[
+        delayed_job
+        elasticsearch
+        faraday
+        http
+        json
+        mongo
+        net_http
+        redis
+        sequel
+        sidekiq
+        sinatra
+        tilt
+        rake
+      ]
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def enabled_instrumentations
+      available_instrumentations - disabled_instrumentations
+    end
+
+    def method_missing(name, *args)
+      return super unless DEPRECATED_OPTIONS.include?(name)
+      warn "The option `#{name}' has been removed."
+    end
+
+    def app=(app)
+      case app_type?(app)
+      when :sinatra
+        set_sinatra(app)
+      when :rails
+        set_rails(app)
+      else
+        self.service_name = 'ruby'
+      end
+    end
+
+    def use_ssl?
+      server_url.start_with?('https')
+    end
+
+    def collect_metrics?
+      metrics_interval > 0
+    end
+
+    def span_frames_min_duration?
+      span_frames_min_duration != 0
+    end
+
+    def span_frames_min_duration=(value)
+      super
+      @span_frames_min_duration_us = nil
+    end
+
+    def span_frames_min_duration_us
+      @span_frames_min_duration_us ||= span_frames_min_duration * 1_000_000
+    end
+
+    def inspect
+      super.split.first + '>'
+    end
+
+    private
+
+    def load_config_file
+      return unless File.exist?(config_file)
+
+      read = File.read(config_file)
+      evaled = ERB.new(read).result
+      YAML.safe_load(evaled)
+    end
+
+    def load_env
+      @options.values.each_with_object({}) do |option, opts|
+        next unless (value = ENV[option.env_key])
+        opts[option.key] = value
+      end
+    end
+
+    def build_logger
+      Logger.new(log_path == '-' ? STDOUT : log_path).tap do |logger|
+        logger.level = log_level
+      end
+    end
+
+    def app_type?(app)
+      if defined?(::Rails::Application) && app.is_a?(::Rails::Application)
+        return :rails
+      end
+
+      if app.is_a?(Class) && app.superclass.to_s == 'Sinatra::Base'
+        return :sinatra
+      end
+
+      nil
+    end
+
+    def set_sinatra(app)
+      self.service_name = format_name(service_name || app.to_s)
+      self.framework_name = framework_name || 'Sinatra'
+      self.framework_version = framework_version || Sinatra::VERSION
+      self.__root_path = Dir.pwd
+    end
+
+    def set_rails(app) # rubocop:disable Metrics/AbcSize
+      self.service_name ||= format_name(service_name || rails_app_name(app))
+      self.framework_name ||= 'Rails'
+      self.framework_version ||= ::Rails::VERSION::STRING
+      self.logger ||= ::Rails.logger
+
+      self.__root_path = ::Rails.root.to_s
+      self.__view_paths = app.config.paths['app/views'].existent
+    end
+
+    def rails_app_name(app)
+      if ::Rails::VERSION::MAJOR >= 6
+        app.class.module_parent_name
+      else
+        app.class.parent_name
+      end
+    end
+
+    def format_name(str)
+      str && str.gsub('::', '_')
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end