elastic-apm 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/with_framework

@@ -0,0 +1,7 @@
+#!/bin/bash -x
+set -e
+
+framework=$1
+
+FRAMEWORK=$framework bundle update
+FRAMEWORK=$framework ${@:2}

data/elastic-apm.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elastic_apm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'elastic-apm'
+  spec.version       = ElasticAPM::VERSION
+  spec.authors       = ['Mikkel Malmberg']
+  spec.email         = ['mikkel@elastic.co']
+
+  spec.summary       = 'The official Elastic APM agent for Ruby'
+  spec.homepage      = 'https://github.com/elastic/apm-agent-ruby'
+  spec.license       = 'Apache-2.0'
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_dependency('activesupport', '>= 3.0.0')
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ['lib']
+end

data/lib/elastic-apm.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Make bundler auto-require work
+require 'elastic_apm'

data/lib/elastic_apm.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/version'
+require 'elastic_apm/log'
+
+# Core
+require 'elastic_apm/agent'
+require 'elastic_apm/config'
+require 'elastic_apm/instrumenter'
+require 'elastic_apm/internal_error'
+require 'elastic_apm/util'
+
+# Metrics
+require 'elastic_apm/middleware'
+
+require 'elastic_apm/railtie' if defined?(::Rails::Railtie)
+
+# ElasticAPM
+module ElasticAPM
+  ### Life cycle
+
+  # Starts the ElasticAPM Agent
+  #
+  # @param config [Config] An instance of Config
+  # @return [Agent] The resulting [Agent]
+  def self.start(config = {})
+    Agent.start config
+  end
+
+  # Stops the ElasticAPM Agent
+  def self.stop
+    Agent.stop
+  end
+
+  # @return [Boolean] Whether there's an [Agent] running
+  def self.running?
+    Agent.running?
+  end
+
+  # @return [Agent] Currently running [Agent] if any
+  def self.agent
+    Agent.instance
+  end
+
+  ### Metrics
+
+  # Returns the currently active transaction (if any)
+  #
+  # @return [Transaction] if any
+  def self.current_transaction
+    agent && agent.current_transaction
+  end
+
+  # Start a new transaction or return the currently running
+  #
+  # @param name [String] A description of the transaction, eg
+  # `ExamplesController#index`
+  # @param type [String] The kind of the transaction, eg `app.request.get` or
+  # `db.mysql2.query`
+  # @yield [Transaction] Optional block encapsulating transaction
+  # @return [Transaction] Unless block given
+  def self.transaction(name, type = nil, &block)
+    agent && agent.transaction(name, type, &block)
+  end
+
+  # Starts a new span under the current Transaction
+  #
+  # @param name [String] A description of the span, eq `SELECT FROM "users"`
+  # @param type [String] The kind of span, eq `db.mysql2.query`
+  # @param context [Span::Context] Context information about the span
+  # @yield [Span] Optional block encapsulating span
+  # @return [Span] Unless block given
+  def self.span(name, type = nil, context: nil, &block)
+    agent && agent.span(name, type, context: context, &block)
+  end
+
+  ### Errors
+
+  # Report and exception to APM
+  #
+  # @param exception [Exception] The exception
+  # @param rack_env [Rack::Env] An optional Rack env
+  # @param handled [Boolean] Whether the exception was rescued
+  # @return [Error] An [Error] instance
+  def self.report(exception, rack_env: nil, handled: true)
+    agent && agent.report(exception, rack_env: rack_env, handled: handled)
+  end
+
+  def self.report_message(message, **attrs)
+    agent && agent.report_message(message, backtrace: caller, **attrs)
+  end
+end

data/lib/elastic_apm/agent.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/error_builder'
+require 'elastic_apm/error'
+require 'elastic_apm/http'
+require 'elastic_apm/injectors'
+require 'elastic_apm/serializers'
+require 'elastic_apm/worker'
+
+module ElasticAPM
+  # rubocop:disable Metrics/ClassLength
+  # @api private
+  class Agent
+    include Log
+
+    LOCK = Mutex.new
+
+    # life cycle
+
+    def self.instance # rubocop:disable Style/TrivialAccessors
+      @instance
+    end
+
+    def self.start(config)
+      return @instance if @instance
+
+      LOCK.synchronize do
+        return @instance if @instance
+        @instance = new(config).start
+      end
+    end
+
+    def self.stop
+      LOCK.synchronize do
+        return unless @instance
+
+        @instance.stop
+        @instance = nil
+      end
+    end
+
+    def self.running?
+      !!@instance
+    end
+
+    def initialize(config)
+      config = Config.new(config) if config.is_a?(Hash)
+
+      @config = config
+
+      @queue = Queue.new
+
+      @instrumenter = Instrumenter.new(config, self)
+      @error_builder = ErrorBuilder.new(config)
+
+      @serializers = Struct.new(:transactions, :errors).new(
+        Serializers::Transactions.new(config),
+        Serializers::Errors.new(config)
+      )
+    end
+
+    attr_reader :config, :queue, :instrumenter
+
+    def start
+      debug 'Starting agent reporting to %s', config.server
+
+      @instrumenter.start
+
+      boot_worker
+
+      config.enabled_injectors.each do |lib|
+        require "elastic_apm/injectors/#{lib}"
+      end
+
+      self
+    end
+
+    def stop
+      debug 'Stopping agent'
+
+      @instrumenter.stop
+
+      kill_worker
+
+      self
+    end
+
+    at_exit do
+      stop
+    end
+
+    def enqueue_transactions(transactions)
+      data = @serializers.transactions.build_all(transactions)
+      @queue << Worker::Request.new('/v1/transactions', data)
+    end
+
+    def enqueue_errors(errors)
+      data = @serializers.errors.build_all(errors)
+      @queue << Worker::Request.new('/v1/errors', data)
+      errors
+    end
+
+    # instrumentation
+
+    def current_transaction
+      instrumenter.current_transaction
+    end
+
+    def transaction(*args, &block)
+      instrumenter.transaction(*args, &block)
+    end
+
+    def span(*args, &block)
+      instrumenter.span(*args, &block)
+    end
+
+    # errors
+
+    def report(exception, rack_env: nil, handled: true)
+      error = @error_builder.build_exception(
+        exception,
+        rack_env: rack_env,
+        handled: handled
+      )
+      enqueue_errors error
+    end
+
+    def report_message(message, backtrace: nil, **attrs)
+      error = @error_builder.build_log(
+        message,
+        backtrace: backtrace,
+        **attrs
+      )
+      enqueue_errors error
+    end
+
+    def inspect
+      '<ElasticAPM::Agent>'
+    end
+
+    private
+
+    def boot_worker
+      debug 'Booting worker in thread'
+
+      @worker_thread = Thread.new do
+        Worker.new(@config, @queue).run_forever
+      end
+    end
+
+    def kill_worker
+      @queue << Worker::StopMessage.new
+
+      unless @worker_thread.join(5) # 5 secs
+        raise 'Failed to wait for worker, not all messages sent'
+      end
+
+      @worker_thread = nil
+
+      debug 'Killed worker'
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/elastic_apm/config.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module ElasticAPM
+  # @api private
+  class Config
+    DEFAULTS = {
+      server: 'http://localhost:8200',
+      secret_token: nil,
+
+      app_name: nil,
+      environment: nil,
+      framework_name: nil,
+      framework_version: nil,
+
+      log_path: '-',
+      log_level: Logger::INFO,
+
+      timeout: 10,
+      open_timeout: 10,
+      transaction_send_interval: 10,
+      debug_transactions: false,
+      debug_http: false,
+
+      enabled_injectors: %w[net_http],
+
+      view_paths: []
+    }.freeze
+
+    LOCK = Mutex.new
+
+    def initialize(options = nil)
+      options = {} if options.nil?
+
+      DEFAULTS.merge(options).each do |key, value|
+        send("#{key}=", value)
+      end
+
+      return unless block_given?
+
+      yield self
+    end
+
+    attr_accessor :server
+    attr_accessor :secret_token
+
+    attr_accessor :app_name
+    attr_writer :environment
+    attr_accessor :framework_name
+    attr_accessor :framework_version
+
+    attr_accessor :log_path
+    attr_accessor :log_level
+
+    attr_accessor :timeout
+    attr_accessor :open_timeout
+    attr_accessor :transaction_send_interval
+    attr_accessor :debug_transactions
+    attr_accessor :debug_http
+
+    attr_accessor :enabled_injectors
+
+    attr_accessor :view_paths
+
+    attr_writer :logger
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def app=(app)
+      case app_type?(app)
+      when :sinatra
+        self.app_name = format_name(app_name || app.to_s)
+        self.framework_name = 'Sinatra'
+        self.framework_version = Sinatra::VERSION
+      when :rails
+        self.app_name = format_name(app_name || app.class.parent_name)
+        self.framework_name = 'Ruby on Rails'
+        self.framework_version = Rails::VERSION::STRING
+        self.logger = Rails.logger
+        self.view_paths = app.config.paths['app/views'].existent
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def app_type?(app)
+      if defined?(::Rails) && 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 environment
+      @environment ||= ENV['RAILS_ENV'] || ENV['RACK_ENV']
+    end
+
+    def logger
+      @logger ||=
+        LOCK.synchronize do
+          build_logger(log_path, log_level)
+        end
+    end
+
+    def use_ssl?
+      server.start_with?('https')
+    end
+
+    private
+
+    def build_logger(path, level)
+      logger = Logger.new(path == '-' ? STDOUT : path)
+      logger.level = level
+      logger
+    end
+
+    def format_name(str)
+      str.gsub('::', '_')
+    end
+  end
+end

data/lib/elastic_apm/error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/stacktrace'
+require 'elastic_apm/error/exception'
+require 'elastic_apm/error/log'
+require 'elastic_apm/error/context'
+
+module ElasticAPM
+  # @api private
+  class Error
+    def initialize(culprit: nil)
+      @culprit = culprit
+
+      @timestamp = Util.micros
+      @context = Context.new
+    end
+
+    attr_accessor :culprit, :exception, :log
+    attr_reader :timestamp, :context
+  end
+end