atatus 1.0.0

data/bench/app.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'active_record'
+require 'action_controller/railtie'
+require 'atatus'
+require 'atatus/railtie'
+
+$log = Logger.new('/tmp/bench.log')
+
+ActiveRecord::Base.logger = $log
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: '/tmp/bench.sqlite3')
+
+ActiveRecord::Schema.define do
+  create_table :posts, force: true do |t|
+    t.string :title
+    t.timestamps
+  end
+end
+
+class Post < ActiveRecord::Base
+end
+
+10.times { |i| Post.create! title: "Post #{i}" }
+
+class ApplicationController < ActionController::Base
+  def index
+    render inline: '<%= Post.pluck(:title).join(", ") %>'
+  end
+
+  def favicon
+    render nothing: true
+  end
+end
+
+class App < Rails::Application
+  config.secret_key_base = '__secret'
+  config.logger = $log
+  config.eager_load = false
+
+  config.atatus.disable_send = true
+  config.atatus.logger = $log
+  config.atatus.log_level = Logger::DEBUG
+end
+
+App.initialize!
+
+App.routes.draw do
+  get '/favicon.ico', to: 'application#favicon'
+  root to: 'application#index'
+end

data/bench/benchmark.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV['RAILS_ENV'] = 'production'
+
+require 'bundler'
+require 'bundler/setup'
+
+require 'benchmark'
+include Benchmark
+require 'rack/test'
+
+require './bench/app'
+
+def app
+  App
+end
+
+include Rack::Test::Methods
+
+def perform
+  10_000.times do
+    get '/'
+  end
+end
+
+bench = Benchmark.benchmark(CAPTION, 15, FORMAT) do |b|
+  perform # warm up
+
+  b.report('with agent:') { perform }
+
+  Atatus.stop
+  perform # warm up
+
+  b.report('without agent:') { perform }
+end

data/bench/report.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+
+input = STDIN.read.split("\n")
+
+git_sha, git_msg = `git log -n 1 --pretty="format:%H|||%s"`.split('|||')
+git_date = `git log -n 1 --pretty="format:%ai"`
+platform = Gem::Platform.local
+
+def doc(payload)
+  puts({ index: { _index: "benchmark-ruby", _type: "_doc" } }.to_json)
+  puts(payload.to_json)
+end
+
+meta = {
+  executed_at: Time.new.iso8601,
+  'git.commit' => git_sha,
+  'git.date' => String(git_date).strip != '' && Time.parse(git_date).iso8601,
+  'git.subject' => git_msg,
+  hostname: `hostname`.chomp,
+  engine: RUBY_ENGINE,
+  arch: platform.cpu,
+  os: platform.os,
+  ruby_version: "#{RUBY_ENGINE == 'jruby' ? 'j' : ''}#{RUBY_VERSION}"
+}
+
+results =
+  input
+  .grep(/^with/)
+  .map do |line|
+    title = line.match(/^(.*):/) { |m| m[1] }
+    user, system, total, real = line.scan(/[0-9\.]+/).map(&:to_f)
+    meta.merge(
+      title: title,
+      user: user,
+      system: system,
+      total: total,
+      real: real,
+    )
+  end
+
+results.each { |result| doc result }
+
+overhead =
+  (results[0][:total] - results[1][:total]) *
+  1000 /  # milliseconds
+  10_000     # transactions
+
+doc meta.merge(
+  title: 'overhead',
+  overhead: overhead
+)

data/bench/rubyprof.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'ruby-prof'
+require 'rack/test'
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'atatus'
+
+require './bench/app'
+include App::Helpers
+
+def perform(app, count: 1000)
+  app.start
+
+  transactions = count.times.map do |i|
+    Atatus.transaction "Transaction##{i}",
+      context: Atatus.build_context(app.mock_env) do
+      Atatus.span('Number one') { 'ok 1' }
+      Atatus.span('Number two') { 'ok 2' }
+      Atatus.span('Number three') { 'ok 3' }
+    end
+  end
+
+  app.stop
+end
+
+def do_bench(transaction_count: 1000, **config)
+  with_app(config) do |app|
+    profile = RubyProf::Profile.new
+    profile.exclude_common_methods!
+    profile.start
+    perform(app, count: transaction_count)
+    profile.stop
+    printer = RubyProf::GraphHtmlPrinter.new(profile)
+    printer.print(File.open('bench/tmp/out.html', 'w'))
+  end
+end
+
+do_bench(transaction_count: 10_000)

data/bench/stackprof.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'stackprof'
+require 'rack/test'
+
+require './bench/app'
+
+def app
+  App
+end
+
+include Rack::Test::Methods
+
+puts 'Running '
+profile = StackProf.run(mode: :cpu) do
+  10_000.times do
+    get '/'
+  end
+end
+puts ''
+
+StackProf::Report.new(profile).print_text

data/bin/build_docs

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -ex
+
+# Requires atatus/docs to be checked out at ../docs
+../docs/build_docs.pl --doc docs/index.asciidoc --chunk 1

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'atatus'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

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/lib/atatus.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require 'atatus/version'
+require 'atatus/internal_error'
+require 'atatus/logging'
+
+# Core
+require 'atatus/agent'
+require 'atatus/config'
+require 'atatus/context'
+require 'atatus/instrumenter'
+require 'atatus/util'
+
+require 'atatus/middleware'
+
+require 'atatus/railtie' if defined?(::Rails::Railtie)
+
+# Atatus
+module Atatus # rubocop:disable Metrics/ModuleLength
+  class << self
+    ### Life cycle
+
+    # Starts the Atatus Agent
+    #
+    # @param config [Config] An instance of Config
+    # @return [Agent] The resulting [Agent]
+    def start(config = {})
+      Agent.start config
+    end
+
+    # Stops the Atatus Agent
+    def stop
+      Agent.stop
+    end
+
+    # @return [Boolean] Whether there's an [Agent] running
+    def running?
+      Agent.running?
+    end
+
+    # @return [Agent] Currently running [Agent] if any
+    def agent
+      Agent.instance
+    end
+
+    ### Metrics
+
+    # Returns the currently active transaction (if any)
+    #
+    # @return [Transaction] or `nil`
+    def current_transaction
+      agent&.current_transaction
+    end
+
+    # Returns the currently active span (if any)
+    #
+    # @return [Span] or `nil`
+    def current_span
+      agent&.current_span
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # Get a formatted string containing transaction, span, and trace ids.
+    # If a block is provided, the ids are yielded.
+    #
+    # @yield [String|nil, String|nil, String|nil] The transaction, span,
+    # and trace ids.
+    # @return [String] Unless block given
+    def log_ids
+      trace_id = (current_transaction || current_span)&.trace_id
+      if block_given?
+        return yield(current_transaction&.id, current_span&.id, trace_id)
+      end
+
+      ids = []
+      ids << "transaction.id=#{current_transaction.id}" if current_transaction
+      ids << "span.id=#{current_span.id}" if current_span
+      ids << "trace.id=#{trace_id}" if trace_id
+      ids.join(' ')
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # rubocop:disable Metrics/MethodLength
+    # Start a new transaction
+    #
+    # @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`
+    # @param context [Context] An optional [Context]
+    # @return [Transaction]
+    def start_transaction(
+      name = nil,
+      type = nil,
+      context: nil,
+      trace_context: nil
+    )
+      agent&.start_transaction(
+        name,
+        type,
+        context: context,
+        trace_context: trace_context
+      )
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Ends the current transaction with `result`
+    #
+    # @param result [String] The result of the transaction
+    # @return [Transaction]
+    def end_transaction(result = nil)
+      agent&.end_transaction(result)
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    # Wrap a block in a Transaction, ending it after the block
+    #
+    # @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`
+    # @param context [Context] An optional [Context]
+    # @yield [Transaction]
+    # @return result of block
+    def with_transaction(
+      name = nil,
+      type = nil,
+      context: nil,
+      trace_context: nil
+    )
+      unless block_given?
+        raise ArgumentError,
+          'expected a block. Do you want `start_transaction\' instead?'
+      end
+
+      return yield(nil) unless agent
+
+      begin
+        transaction =
+          start_transaction(
+            name,
+            type,
+            context: context,
+            trace_context: trace_context
+          )
+        yield transaction
+      ensure
+        end_transaction
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Start a new span
+    #
+    # @param name [String] A description of the span, eq `SELECT FROM "users"`
+    # @param type [String] The span type, eq `db`
+    # @param subtype [String] The span subtype, eq `postgresql`
+    # @param action [String] The span action type, eq `connect` or `query`
+    # @param context [Span::Context] Context information about the span
+    # @param include_stacktrace [Boolean] Whether or not to capture a stacktrace
+    # @return [Span]
+    def start_span(
+      name,
+      type = nil,
+      subtype: nil,
+      action: nil,
+      context: nil,
+      include_stacktrace: true,
+      trace_context: nil
+    )
+      agent&.start_span(
+        name,
+        type,
+        subtype: subtype,
+        action: action,
+        context: context,
+        trace_context: trace_context
+      ).tap do |span|
+        break unless span && include_stacktrace
+        break unless agent.config.span_frames_min_duration?
+
+        span.original_backtrace ||= caller
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    # Ends the current span
+    #
+    # @return [Span]
+    def end_span
+      agent&.end_span
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    # Wrap a block in a Span, ending it after the block
+    #
+    # @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
+    # @param include_stacktrace [Boolean] Whether or not to capture a stacktrace
+    # @yield [Span]
+    # @return Result of block
+    def with_span(
+      name,
+      type = nil,
+      subtype: nil,
+      action: nil,
+      context: nil,
+      include_stacktrace: true,
+      trace_context: nil
+    )
+      unless block_given?
+        raise ArgumentError,
+          'expected a block. Do you want `start_span\' instead?'
+      end
+
+      return yield nil unless agent
+
+      begin
+        span =
+          start_span(
+            name,
+            type,
+            subtype: subtype,
+            action: action,
+            context: context,
+            include_stacktrace: include_stacktrace,
+            trace_context: trace_context
+          )
+        yield span
+      ensure
+        end_span
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    # Build a [Context] from a Rack `env`. The context may include information
+    # about the request, response, current user and more
+    #
+    # @param rack_env [Rack::Env] A Rack env
+    # @return [Context] The built context
+    def build_context(
+      rack_env: nil,
+      for_type: :transaction
+    )
+      agent&.build_context(rack_env: rack_env, for_type: for_type)
+    end
+
+    ### Errors
+
+    # Report and exception to APM
+    #
+    # @param exception [Exception] The exception
+    # @param context [Context] An optional [Context]
+    # @param handled [Boolean] Whether the exception was rescued
+    # @return [String] ID of the generated [Error]
+    def report(exception, context: nil, handled: true)
+      agent&.report(exception, context: context, handled: handled)
+    end
+
+    # Report a custom string error message to APM
+    #
+    # @param message [String] The message
+    # @param context [Context] An optional [Context]
+    # @return [String] ID of the generated [Error]
+    def report_message(message, context: nil, **attrs)
+      agent&.report_message(
+        message,
+        context: context,
+        backtrace: caller,
+        **attrs
+      )
+    end
+
+    ### Context
+
+    # Set a _label_ value for the current transaction
+    #
+    # @param key [String,Symbol] A key
+    # @param value [Object] A value
+    # @return [Object] The given value
+    def set_label(key, value)
+      case value
+      when TrueClass,
+           FalseClass,
+           Numeric,
+           NilClass,
+           String
+        agent&.set_label(key, value)
+      else
+        agent&.set_label(key, value.to_s)
+      end
+    end
+
+    # Provide further context for the current transaction
+    #
+    # @param custom [Hash] A hash with custom information. Can be nested.
+    # @return [Hash] The current custom context
+    def set_custom_context(custom)
+      agent&.set_custom_context(custom)
+    end
+
+    # Provide a user to the current transaction
+    #
+    # @param user [Object] An object representing a user
+    # @return [Object] Given user
+    def set_user(user)
+      agent&.set_user(user)
+    end
+
+    # Provide a filter to transform payloads before sending them off
+    #
+    # @param key [Symbol] Unique filter key
+    # @param callback [Object, Proc] A filter that responds to #call(payload)
+    # @yield [Hash] A filter. Used if provided. Otherwise using `callback`
+    # @return [Bool] true
+    def add_filter(key, callback = nil, &block)
+      if callback.nil? && !block_given?
+        raise ArgumentError, '#add_filter needs either `callback\' or a block'
+      end
+
+      agent&.add_filter(key, block || callback)
+    end
+  end
+end