heimdall_apm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f1d534cb7c6454c3d80e42c5a5d6c43eb399fe4
+  data.tar.gz: 50874cb30661dc750183cc6aa0694bbc78db3cd2
+SHA512:
+  metadata.gz: 701c5cb8ef98c9c27c5d368cec5bddcc90b6627a7d676887424f4b6277e3ad13d337235815afa938660f5a4586a30ff9680cc4da1fe4dd7e2b5069a8e0eb8694
+  data.tar.gz: 4710a3e60d589f3d5582fbe989d0de66e50da4dbb5c92a78be225c7f90bee37567bee4425fde4a7655ce294089d3ff905443833991a318c0c19f13d68f219db2

data/.gitignore

@@ -0,0 +1,9 @@
+# misc
+.DS_Store
+
+# Ruby
+.bundle/
+.yardoc
+coverage/
+doc/
+tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.2
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in heimdall.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    heimdall_apm (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-16
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  heimdall_apm!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1 @@
+# Heimdall APM

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/heimdall_apm.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "heimdall_apm/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "heimdall_apm"
+  spec.version       = HeimdallApm::VERSION
+  spec.authors       = ["Christopher Cocchi-Perrier"]
+  spec.email         = ["cocchi.c@gmail.com"]
+  spec.license       = 'LGPL-3.0'
+
+  spec.summary       = "Open source monitoring for Rails applications"
+  spec.homepage      = "https://github.com/ccocchi/heimdall"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.start_with?('test', 'bin')
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/heimdall_apm/agent.rb

@@ -0,0 +1,96 @@
+require 'heimdall_apm/agent_context'
+require 'heimdall_apm/reporting'
+
+module HeimdallApm
+  # Main entry point for HeimdallApm. Only one instance is created per ruby
+  # process, and it manages the lifecycle of the monitoring
+  #
+  class Agent
+    DEFAULT_PUSH_INTERVAL = 60
+
+    @@instance = nil
+
+    def self.instance(opts = {})
+      @@instance ||= self.new(opts)
+    end
+
+    attr_reader :options
+
+    attr_reader :context
+
+    def initialize(opts)
+      @options            = opts
+      @context            = ::HeimdallApm::AgentContext.new
+      @background_thread  = nil
+      @stopped            = false
+    end
+
+    def install(options = {})
+      context.config = ::HeimdallApm::Config.new
+
+      if context.interactive?
+        HeimdallApm.logger.info 'Preventing agent to start in interactive mode'
+        return
+      end
+
+      if defined?(Sidekiq) && Sidekiq.server?
+        # TODO: handle custom instrumentation disabling
+        HeimdallApm.logger.info 'Preventing agent to start in sidekiq server'
+        return
+      end
+
+      start(options)
+    end
+
+    def start(options = {})
+      return unless context.config.value('enabled')
+
+      @background_thread = Thread.new { background_run }
+
+      # TODO: use instruments manager
+      require 'heimdall_apm/instruments/active_record'      if defined?(ActiveRecord)
+      require 'heimdall_apm/instruments/action_controller'  if defined?(ActionController)
+      require 'heimdall_apm/instruments/elasticsearch'      if defined?(Elasticsearch)
+
+      if (options[:app])
+        require 'heimdall_apm/instruments/middleware'
+        # TODO: make the position configurable
+        options[:app].config.middleware.insert_after Rack::Cors, HeimdallApm::Instruments::Middleware
+      end
+    end
+
+    def stop
+      @stopped = true
+      if @background_thread.alive?
+        @background_thread.wakeup
+        @background_thread.join
+      end
+    end
+
+    private
+
+    def background_run
+      HeimdallApm.logger.info "Start background thread"
+      reporting = ::HeimdallApm::Reporting.new(@context)
+      next_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + DEFAULT_PUSH_INTERVAL
+
+      loop do
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        break if @stopped
+
+        if now < next_time
+          remaining = next_time - now
+          HeimdallApm.logger.debug "Sleeping for #{remaining}"
+          sleep(remaining)
+          next
+        end
+
+        reporting.call
+        next_time = now + DEFAULT_PUSH_INTERVAL
+      end
+    rescue => e
+      HeimdallApm.logger.error e.message
+    end
+  end
+end

data/lib/heimdall_apm/agent_context.rb

@@ -0,0 +1,30 @@
+require 'heimdall_apm/vault'
+require 'heimdall_apm/recorder'
+require 'heimdall_apm/config'
+
+module HeimdallApm
+  # Global context in which the agent is run. One context is assigned per
+  # agent. It contains most of the part that are going to be accessed globally
+  # by the rest of the monitoring.
+  #
+  class AgentContext
+    # Global configuration object
+    attr_writer :config
+
+    def config
+      @config ||= ::HeimdallApm::Config.new
+    end
+
+    def vault
+      @vault ||= ::HeimdallApm::Vault.new(self)
+    end
+
+    def recorder
+      @recorder ||= ::HeimdallApm::Recorder.new
+    end
+
+    def interactive?
+      defined?(::Rails::Console) && $stdout.isatty && $stdin.isatty
+    end
+  end
+end

data/lib/heimdall_apm/config.rb

@@ -0,0 +1,28 @@
+module HeimdallApm
+  class Config
+    def initialize
+      @loaded = nil
+      load_default_config
+    end
+
+    def value(key)
+      # TODO: handle empty strings keys or boolean passed as strings
+      @loaded && @settings[key]
+    end
+    alias_method :[], :value
+
+    def has_key?(key)
+      @settings.key?(key)
+    end
+    alias_method :key?, :has_key?
+
+    private
+
+    def load_default_config
+      @settings = Rails.application.config_for(:heimdall_apm)
+      @loaded   = true
+    rescue
+      # TODO: handle no configuration file found
+    end
+  end
+end

data/lib/heimdall_apm/instruments/action_controller.rb

@@ -0,0 +1,24 @@
+module HeimdallApm
+  module ActionController
+    class Subscriber
+      def start(name, id, payload)
+        txn     = ::HeimdallApm::TransactionManager.current
+        scope   = -"#{payload[:controller]}##{payload[:action]}"
+        segment = ::HeimdallApm::Segment.new('Controller'.freeze, scope)
+
+        txn.scope = scope unless txn.scope
+        txn.start_segment(segment)
+      end
+
+      def finish(name, id, payload)
+        txn = ::HeimdallApm::TransactionManager.current
+        txn.stop_segment
+      end
+    end
+  end
+end
+
+ActiveSupport::Notifications.subscribe(
+  'process_action.action_controller',
+  ::HeimdallApm::ActionController::Subscriber.new
+)

data/lib/heimdall_apm/instruments/active_record.rb

@@ -0,0 +1,23 @@
+module HeimdallApm
+  module ActiveRecord
+    class Subscriber
+      def start(name, id, payload)
+        txn     = ::HeimdallApm::TransactionManager.current
+        segment = ::HeimdallApm::Segment.new('Sql'.freeze, name)
+        segment.data = payload[:sql]
+
+        txn.start_segment(segment)
+      end
+
+      def finish(name, id, payload)
+        txn = ::HeimdallApm::TransactionManager.current
+        txn.stop_segment
+      end
+    end
+  end
+end
+
+ActiveSupport::Notifications.subscribe(
+  'sql.active_record',
+  ::HeimdallApm::ActiveRecord::Subscriber.new
+)

data/lib/heimdall_apm/instruments/elasticsearch.rb

@@ -0,0 +1,23 @@
+module HeimdallApm
+  module Elasticsearch
+    class Subscriber
+      def start(name, id, payload)
+        txn     = ::HeimdallApm::TransactionManager.current
+        segment = ::HeimdallApm::Segment.new('Elastic'.freeze, name)
+        segment.data = payload[:search]
+
+        txn.start_segment(segment)
+      end
+
+      def finish(name, id, payload)
+        txn = ::HeimdallApm::TransactionManager.current
+        txn.stop_segment
+      end
+    end
+  end
+end
+
+ActiveSupport::Notifications.subscribe(
+  'search.elasticsearch',
+  ::HeimdallApm::Elasticsearch::Subscriber.new
+)

data/lib/heimdall_apm/instruments/middleware.rb

@@ -0,0 +1,18 @@
+module HeimdallApm
+  module Instruments
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        txn     = ::HeimdallApm::TransactionManager.current
+        segment = ::HeimdallApm::Segment.new('Middleware'.freeze, 'all'.freeze)
+        txn.start_segment(segment)
+        @app.call(env)
+      ensure
+        txn.stop_segment
+      end
+    end
+  end
+end

data/lib/heimdall_apm/metric_name.rb

@@ -0,0 +1,19 @@
+module HeimdallApm
+  # Metric name used in visitor's metrics hash
+  #
+  class MetricName
+    attr_reader :type, :name, :scope
+
+    def initialize(type, name, scope = nil)
+      @type   = type
+      @name   = name
+      @scope  = scope
+    end
+
+    def hash
+      h = type.hash ^ name.hash
+      h ^= scope.hash if scope
+      h
+    end
+  end
+end

data/lib/heimdall_apm/metric_stats.rb

@@ -0,0 +1,33 @@
+module HeimdallApm
+  # Stats associated with a single metric (used in metrics Hashs as value where
+  # keys are the metrics names)
+  #
+  class MetricStats
+    attr_accessor :call_count
+    attr_accessor :total_call_time
+    attr_accessor :total_exclusive_time
+    attr_accessor :min_call_time
+    attr_accessor :max_call_time
+
+    # If this metric is scoped inside another, use exclusive time for min/max.
+    # Non-scoped metrics (like Controller) track the total call time.
+    def initialize(scoped: false)
+      @scoped = scoped
+      @call_count = 0
+      @total_call_time = 0.0
+      @total_exclusive_time = 0.0
+      @min_call_time = 0.0
+      @max_call_time = 0.0
+    end
+
+    def update(call_time, exclusive_time = nil)
+      self.call_count += 1
+      self.total_call_time += call_time
+      self.total_exclusive_time += exclusive_time
+
+      t = @scoped ? exclusive_time : call_time
+      self.min_call_time = t if call_count == 0 || t < min_call_time
+      self.max_call_time = t if t > max_call_time
+    end
+  end
+end

data/lib/heimdall_apm/points_collection.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module HeimdallApm
+  # Convert metrics hash from requests into an collection of points we want to
+  # track, but without aggregations and percentiles/std_dev calculations of same
+  # endpoints across multiples requests. These operations are deferred to
+  # InfluxDB, in favor of more granular data.
+  # This may change in the future if it proves non scalable.
+  #
+  class PointsCollection
+    # Metrics we want to explicitely keep separated into measurements. Everything
+    # else will be label as Ruby.
+    ROOT_METRICS = Set.new(['Sql', 'Elastic', 'Redis'])
+
+    def initialize
+      @points = []
+    end
+
+    def empty?
+      @points.empty?
+    end
+
+    def to_a
+      @points
+    end
+
+    def append(txn, metrics)
+      timestamp   = txn.root_segment.stop_time
+      series_name = txn.custom_series_name || (txn.web? ? 'app' : 'job')
+      values      = Hash.new { |h, k| h[k] = 0 }
+
+      tags = txn.tags || {}
+      tags[:endpoint] = txn.scope
+
+      metrics.each do |meta, stat|
+        if ROOT_METRICS.include?(meta.type)
+          key = -"#{meta.type.downcase}_time"
+          values[key] += stat.total_exclusive_time
+        else
+          values['ruby_time'] += stat.total_exclusive_time
+        end
+
+        values['total_time'] += stat.total_exclusive_time
+      end
+
+      # Segment time are in seconds, store them in milliseconds
+      values.transform_values! { |v| v * 1000 }
+
+      @points << {
+        series: series_name,
+        timestamp: (timestamp * 1000).to_i,
+        tags: tags,
+        values: values
+      }
+    end
+  end
+end

data/lib/heimdall_apm/probe.rb

@@ -0,0 +1,25 @@
+module HeimdallApm
+  # Provides helpers for custom instrumentation of code
+  #
+  #   include Probe
+  #   instrument('Elastic', 'profiles#search') do ... end
+  #
+  module Probe
+    # Insruments block passed to the method into the current transaction.
+    #
+    # @param type Segment type (i.e 'ActiveRecord' or similar)
+    # @param name Specific name for the segment
+    #
+    def instrument(type, name, opts = {})
+      txn     = ::HeimdallApm::TransactionManager.current
+      segment = ::HeimdallApm::Segment.new(type, name)
+      txn.start_segment(segment)
+
+      # TODO: maybe yield the segment here to have the block pass additional
+      # informations
+      yield
+    ensure
+      txn.stop_segment
+    end
+  end
+end

data/lib/heimdall_apm/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails/railtie'
+
+module HeimdallApm
+  class Railtie < Rails::Railtie
+    initializer 'heimdall_apm.install' do |app|
+      HeimdallApm::Agent.instance.install(app: app)
+    end
+  end
+end

data/lib/heimdall_apm/recorder.rb

@@ -0,0 +1,8 @@
+module HeimdallApm
+  # TODO: Maybe not needed if we keep transaction logic within visitors
+  class Recorder
+    def record(request)
+      request.record
+    end
+  end
+end

data/lib/heimdall_apm/reporting.rb

@@ -0,0 +1,22 @@
+module HeimdallApm
+  class Reporting
+    def initialize(context)
+      @context = context
+    end
+
+    def influx
+      @client ||= InfluxDB::Client.new("#{Rails.env}_metrics", time_precision: 'ms', retry: 0)
+    end
+
+    def call
+      span = @context.vault.retrieve_and_delete_previous_span
+      if span && !span.points_collection.empty?
+        influx.write_points(span.points_collection.to_a)
+      else
+        HeimdallApm.logger.debug "Nothing to report"
+      end
+    rescue => e
+      HeimdallApm.logger.error "#{e.message} during reporting to InfluxDB"
+    end
+  end
+end

data/lib/heimdall_apm/segment.rb

@@ -0,0 +1,68 @@
+module HeimdallApm
+  class Segment
+    # Generic type of the thing being tracked
+    #   Examples: "ActiveRecord", "SQL", "Controller"
+    attr_reader :type
+
+    # More specific name of the item
+    #   Examples: "User#find", "find_by_sql", "users#index"
+    attr_reader :name
+
+    # Start and stop of this segment
+    attr_reader :start_time, :stop_time
+
+    # Additional data linked to the segment (for example SQL or Elastic queries).
+    # Can be left nil.
+    attr_accessor :data
+
+    def initialize(type, name, start_time = nil)
+      @type       = type
+      @name       = name
+      @start_time = start_time
+      @children   = nil
+    end
+
+    def start
+      @start_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+    end
+
+    # Lazy initialization of children to avoid bloating leaf segments
+    def children
+      @children ||= []
+    end
+
+    def add_child(segment)
+      children << segment
+    end
+
+    # Entry point for visitors depth-first style: start by visiting `self` then
+    # visit all of its children
+    def accept(visitor)
+      visitor.visit(self)
+      if @children
+        visitor.before_children if visitor.respond_to?(:before_children)
+        @children.each { |c| c.accept(visitor) }
+        visitor.after_children if visitor.respond_to?(:after_children)
+      end
+    end
+
+    def record_stop_time
+      @stop_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+    end
+
+    def total_call_time
+      @total_call_time ||= stop_time - start_time
+    end
+
+    def total_exclusive_time
+      return total_call_time unless @children
+      total_call_time - children_call_time
+    end
+
+    private
+
+    def children_call_time
+      children.map(&:total_call_time).sum
+    end
+  end
+end

data/lib/heimdall_apm/tracked_transaction.rb

@@ -0,0 +1,129 @@
+require 'heimdall_apm/visitors/request_metrics_visitor'
+require 'heimdall_apm/visitors/pretty_print_visitor'
+
+module HeimdallApm
+  # A TrackedTransaction is a collection of segments.
+  #
+  class TrackedTransaction
+
+    WEB_MODE = 1
+    JOB_MODE = 2
+
+    # First segment added to the transaction
+    attr_reader :root_segment
+
+    # Recorder used to process transaction data
+    attr_reader :recorder
+
+    # Scope of this transaction (controller routes / job id)
+    attr_accessor :scope
+
+    # Miscellaneous annotations made to the transaction. Must be a Hash.
+    attr_reader :annotations
+
+    def initialize(context)
+      @context      = context
+      @root_segment = nil
+      @segments     = []
+      @scope        = nil
+      @stopped      = false
+      @mode         = nil
+      @annotations  = {}
+
+      @recorder     = context.recorder
+      @vault        = context.vault
+    end
+
+    def start_segment(segment)
+      @root_segment = segment unless @root_segment
+      @segments.push(segment)
+
+      # TODO: maybe use a visitor to check that at the end of the request intead
+      @mode ||=
+        case segment.type
+        when 'Controller' then WEB_MODE
+        when 'Job'        then JOB_MODE
+        else
+          nil
+        end
+
+      segment.start
+    end
+
+    def stop_segment
+      segment = @segments.pop
+      segment.record_stop_time
+
+      if finalized?
+        stop_request
+      else
+        @segments[-1].add_child(segment)
+      end
+    end
+
+    # Grab the currently running segment. Will be `nil` for a finalized
+    # transaction
+    def current_segment
+      @segments[-1]
+    end
+
+    VISITORS = {
+      metrics: ::HeimdallApm::Visitors::RequestMetricsVisitor
+    }
+
+    def record
+      return unless root_segment
+
+      VISITORS.each do |_, klass|
+        visitor = klass.new(@vault, self)
+        root_segment.accept(visitor)
+        visitor.store_in_vault
+      end
+    end
+
+    def stopped?
+      @stopped
+    end
+
+    def annotate(hsh)
+      @annotations.merge!(hsh)
+    end
+
+    # Allows InfluxDB's series name to be customize via annotations
+    def custom_series_name
+      annotations[:series_name]
+    end
+
+    def tags
+      annotations[:tags]
+    end
+
+    def web?
+      @mode == WEB_MODE
+    end
+
+    def job?
+      @mode == JOB_MODE
+    end
+
+    private
+
+    def pretty_print
+      visitor = HeimdallApm::Visitors::PrettyPrintVisitor.new(@scope)
+      root_segment.accept(visitor)
+      visitor.store_in_vault
+    end
+
+    # Send the request off to be stored
+    def stop_request
+      @stopped = true
+      recorder.record(self) if recorder
+    end
+
+    # Are we finished with this transaction, i.e. no layers are left to be
+    # popped out
+    def finalized?
+      @segments.empty?
+    end
+  end
+end

data/lib/heimdall_apm/transaction_manager.rb

@@ -0,0 +1,27 @@
+require 'heimdall_apm/tracked_transaction'
+
+module HeimdallApm
+  # Handles the thread-local variable holding the current tracked transaction,
+  # populating it the first time it is accessed.
+  #
+  class TransactionManager
+    def self.current
+      find || create
+    end
+
+    def self.find
+      req = Thread.current[:heimdall_request]
+
+      if !req || req.stopped?
+        nil
+      else
+        req
+      end
+    end
+
+    def self.create
+      context = Agent.instance.context
+      Thread.current[:heimdall_request] = ::HeimdallApm::TrackedTransaction.new(context)
+    end
+  end
+end

data/lib/heimdall_apm/vault.rb

@@ -0,0 +1,49 @@
+require 'thread'
+require 'heimdall_apm/points_collection'
+
+module HeimdallApm
+  # Keeps in RAM one or more minute's worth of metrics.
+  # When informed to by the background thread, it pushes the in-RAM metrics off
+  # to InfluxDB.
+  class Vault
+    def initialize(context)
+      @context  = context
+      @lock     = Mutex.new
+      @spans    = Hash.new { |h, k| h[k] = Span.new(k, @context) }
+    end
+
+    def current_span
+      @spans[current_timestamp]
+    end
+
+    def retrieve_and_delete_previous_span
+      timestamp = current_timestamp - 60
+      @lock.synchronize { @spans.delete(timestamp) }
+    end
+
+    def store_transaction_metrics(txn, metrics)
+      @lock.synchronize { current_span.add_point(txn, metrics) }
+    end
+
+    def current_timestamp
+      time = Time.now.utc
+      time.to_i - time.sec
+    end
+  end
+
+  # One span of storage
+  class Span
+    attr_reader :points_collection
+
+    def initialize(timestamp, context)
+      @timestamp = timestamp
+      @context   = context
+
+      @points_collection = ::HeimdallApm::PointsCollection.new
+    end
+
+    def add_point(txn, metrics)
+      @points_collection.append(txn, metrics)
+    end
+  end
+end

data/lib/heimdall_apm/version.rb

@@ -0,0 +1,3 @@
+module HeimdallApm
+  VERSION = "0.1.0"
+end

data/lib/heimdall_apm/visitors/pretty_print_visitor.rb

@@ -0,0 +1,42 @@
+module HeimdallApm
+  module Visitors
+    class PrettyPrintVisitor
+      def initialize(scope)
+        @indent = 0
+        @scope  = scope
+
+        @io     = File.open('log/heimdall_apm.log', 'ab')
+        at_exit { @io.close }
+
+        pprint("Request #{@scope}:\n")
+      end
+
+      def before_children
+        @indent += 2
+      end
+
+      def after_children
+        @indent -= 2
+      end
+
+      def visit(segment)
+        pprint("#{segment.type}/#{segment.name}\n")
+        @indent += 2
+        pprint("duration=#{segment.total_exclusive_time}ms\n")
+        @indent -= 2
+      end
+
+      def store_in_vault
+        @io.flush
+      end
+
+      private
+
+      def pprint(str)
+        @io.write(' ' * @indent) if @indent > 0
+        @io.write(str)
+      end
+
+    end
+  end
+end

data/lib/heimdall_apm/visitors/request_metrics_visitor.rb

@@ -0,0 +1,31 @@
+require 'heimdall_apm/metric_name'
+require 'heimdall_apm/metric_stats'
+
+module HeimdallApm
+  module Visitors
+    # Extract metrics for a given transaction
+    #
+    class RequestMetricsVisitor
+      attr_reader :metrics
+
+      def initialize(vault, transaction)
+        @transaction = transaction
+        @vault   = vault
+        @metrics = {}
+      end
+
+      def visit(segment)
+        name = ::HeimdallApm::MetricName.new(segment.type, segment.name)
+        @metrics[name] ||= ::HeimdallApm::MetricStats.new
+
+        stat = @metrics[name]
+        stat.update(segment.total_call_time, segment.total_exclusive_time)
+      end
+
+      def store_in_vault
+        timestamp = @transaction.root_segment.stop_time
+        @vault.store_transaction_metrics(@transaction, metrics)
+      end
+    end
+  end
+end

data/lib/heimdall_apm.rb

@@ -0,0 +1,14 @@
+require 'heimdall_apm/version'
+require 'heimdall_apm/segment'
+require 'heimdall_apm/transaction_manager'
+require 'heimdall_apm/probe'
+require 'heimdall_apm/agent'
+require 'heimdall_apm/railtie' if defined?(Rails)
+
+require 'logger'
+
+module HeimdallApm
+  def self.logger
+    @logger ||= Logger.new('log/heimdall_apm.log')
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: heimdall_apm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christopher Cocchi-Perrier
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- cocchi.c@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- heimdall_apm.gemspec
+- lib/heimdall_apm.rb
+- lib/heimdall_apm/agent.rb
+- lib/heimdall_apm/agent_context.rb
+- lib/heimdall_apm/config.rb
+- lib/heimdall_apm/instruments/action_controller.rb
+- lib/heimdall_apm/instruments/active_record.rb
+- lib/heimdall_apm/instruments/elasticsearch.rb
+- lib/heimdall_apm/instruments/middleware.rb
+- lib/heimdall_apm/metric_name.rb
+- lib/heimdall_apm/metric_stats.rb
+- lib/heimdall_apm/points_collection.rb
+- lib/heimdall_apm/probe.rb
+- lib/heimdall_apm/railtie.rb
+- lib/heimdall_apm/recorder.rb
+- lib/heimdall_apm/reporting.rb
+- lib/heimdall_apm/segment.rb
+- lib/heimdall_apm/tracked_transaction.rb
+- lib/heimdall_apm/transaction_manager.rb
+- lib/heimdall_apm/vault.rb
+- lib/heimdall_apm/version.rb
+- lib/heimdall_apm/visitors/pretty_print_visitor.rb
+- lib/heimdall_apm/visitors/request_metrics_visitor.rb
+homepage: https://github.com/ccocchi/heimdall
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Open source monitoring for Rails applications
+test_files: []