mnemosyne-ruby 0.1.0

data/lib/mnemosyne/probes/action_controller/process_action.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module ActionController
+      module ProcessAction
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'process_action.action_controller'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            meta = {
+              controller: payload[:controller],
+              action: payload[:action],
+              format: payload[:format]
+            }
+
+            span = ::Mnemosyne::Span.new 'app.controller.request.rails',
+              start: start, finish: finish, meta: meta
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register 'ActionController::Base',
+      'action_controller',
+      ActionController::ProcessAction::Probe.new
+  end
+end

data/lib/mnemosyne/probes/action_controller/renderers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module ActionController
+      module Renderers
+        CATEGORY = 'render_to_body.renderers.action_controller'.freeze
+
+        class Probe < ::Mnemosyne::Probe
+          subscribe CATEGORY
+
+          def setup
+            ::ActionController::Base.prepend Instrumentation
+          end
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, _payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            span = ::Mnemosyne::Span.new 'app.controller.renderers.rails',
+              start: start, finish: finish
+
+            trace << span
+          end
+        end
+
+        module Instrumentation
+          def render_to_body(*args, &block)
+            ::ActiveSupport::Notifications.instrument CATEGORY do
+              super
+            end
+          end
+        end
+      end
+    end
+
+    register 'ActionController::Base',
+      'action_controller/metal/renderers',
+      ActionController::Renderers::Probe.new
+  end
+end

data/lib/mnemosyne/probes/action_view/render_partial.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module ActionView
+      module RenderPartial
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'render_partial.action_view'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            span = ::Mnemosyne::Span.new 'view.render.template.rails',
+              start: start, finish: finish, meta: payload
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register nil, nil, ActionView::RenderPartial::Probe.new
+  end
+end

data/lib/mnemosyne/probes/action_view/render_template.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module ActionView
+      module RenderTemplate
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'render_template.action_view'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            span = ::Mnemosyne::Span.new 'view.render.template.rails',
+              start: start, finish: finish, meta: payload
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register nil, nil, ActionView::RenderTemplate::Probe.new
+  end
+end

data/lib/mnemosyne/probes/active_record/query.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module ActiveRecord
+      module Query
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'sql.active_record'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            return if payload[:name] == 'SCHEMA' || payload[:name] == 'CACHE'
+
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            meta = {
+              sql: payload[:sql]
+            }
+
+            span = ::Mnemosyne::Span.new 'db.query.active_record',
+              start: start, finish: finish, meta: meta
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register 'ActiveRecord::Base',
+      'active_record',
+      ActiveRecord::Query::Probe.new
+  end
+end

data/lib/mnemosyne/probes/grape/endpoint_render.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Grape
+      module EndpointRender
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'endpoint_render.grape'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            endpoint = payload[:endpoint]
+            return unless endpoint
+
+            span = ::Mnemosyne::Span.new 'view.render.grape',
+              start: start, finish: finish
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register 'Grape::Endpoint',
+      'grape/endpoint',
+      Grape::EndpointRender::Probe.new
+  end
+end

data/lib/mnemosyne/probes/grape/endpoint_run.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Grape
+      module EndpointRun
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'endpoint_run.grape'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            endpoint = payload[:endpoint]
+            return unless endpoint
+
+            span = ::Mnemosyne::Span.new 'app.controller.request.grape',
+              start: start, finish: finish
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register 'Grape::Endpoint',
+      'grape/endpoint',
+      Grape::EndpointRun::Probe.new
+  end
+end

data/lib/mnemosyne/probes/grape/endpoint_run_filters.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Grape
+      module EndpointRunFilters
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'endpoint_run_filters.grape'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            endpoint = payload[:endpoint]
+            return unless endpoint
+
+            span = ::Mnemosyne::Span.new 'app.controller.filter.grape',
+              start: start, finish: finish
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register 'Grape::Endpoint',
+      'grape/endpoint',
+      Grape::EndpointRunFilters::Probe.new
+  end
+end

data/lib/mnemosyne/probes/mnemosyne/tracer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Mnemosyne
+      module Tracer
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'trace.mnemosyne'
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            span = ::Mnemosyne::Span.new 'custom.trace',
+              start: start, finish: finish, meta: payload
+
+            trace << span
+          end
+        end
+      end
+    end
+
+    register nil, nil, Mnemosyne::Tracer::Probe.new
+  end
+end

data/lib/mnemosyne/probes/responder/respond.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Responder
+      module Respond
+        class Probe < ::Mnemosyne::Probe
+          subscribe 'respond.responders.mnemosyne'
+
+          def setup
+            ::ActionController::Responder.prepend \
+              ::Mnemosyne::Probes::Responder::Respond::Instrumentation
+          end
+
+          # rubocop:disable Metrics/ParameterLists
+          def call(trace, _name, start, finish, _id, _payload)
+            start  = ::Mnemosyne::Clock.to_tick(start)
+            finish = ::Mnemosyne::Clock.to_tick(finish)
+
+            span = ::Mnemosyne::Span.new 'app.responder.respond',
+              start: start, finish: finish
+
+            trace << span
+          end
+        end
+
+        module Instrumentation
+          def respond
+            ::ActiveSupport::Notifications.instrument \
+              'respond.responders.mnemosyne' do
+
+              super
+            end
+          end
+        end
+      end
+    end
+
+    register 'ActionController::Responder',
+      'action_controller/responder',
+      Responder::Respond::Probe.new
+  end
+end

data/lib/mnemosyne/probes/restify/em.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Restify
+      module EM
+        class Probe < ::Mnemosyne::Probe
+          def setup
+            require 'mnemosyne/middleware/restify'
+
+            ::Restify::Adapter::EM::Connection.prepend Instrumentation
+          end
+
+          module Instrumentation
+            def call(request, writer, *args)
+              ::Mnemosyne::Middleware::Restify.call(request, writer) do |r, w|
+                super(r, w, *args)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Restify::Adapter::EM::Connection',
+      'restify/adapter/em',
+      Restify::EM::Probe.new
+  end
+end

data/lib/mnemosyne/probes/restify/typhoeus.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module Probes
+    module Restify
+      module Typhoeus
+        class Probe < ::Mnemosyne::Probe
+          def setup
+            require 'mnemosyne/middleware/restify'
+
+            ::Restify::Adapter::Typhoeus.prepend Instrumentation
+          end
+
+          module Instrumentation
+            def queue(request, writer)
+              ::Mnemosyne::Middleware::Restify.call(request, writer) do |r, w|
+                super(r, w)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Restify::Adapter::Typhoeus',
+      'restify/adapter/typhoeus',
+      Restify::Typhoeus::Probe.new
+  end
+end

data/lib/mnemosyne/probes.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Mnemosyne
+  module Probes
+    class Registration
+      extend ::Forwardable
+
+      attr_reader :class_name, :require_paths
+
+      def initialize(class_name, require_paths, probe)
+        @class_name = class_name
+        @require_paths = Array require_paths
+        @probe = probe
+      end
+
+      def installable?
+        return true unless class_name
+
+        ::Mnemosyne::Probes.class_available? class_name
+      end
+
+      delegate install: :@probe
+    end
+
+    class << self
+      def class_available?(class_name)
+        Module.const_get(class_name).is_a? Class
+      rescue NameError
+        false
+      end
+
+      def register(*args)
+        registration = Registration.new(*args)
+
+        if registration.installable?
+          registration.install
+        else
+          register_require_hook registration
+        end
+      end
+
+      def require_hook(name)
+        registration = require_hooks[name]
+        return unless registration
+        return unless registration.installable?
+
+        registration.install
+
+        unregister_require_hook registration
+      end
+
+      def register_require_hook(registration)
+        registration.require_paths.each do |path|
+          require_hooks[path] = registration
+        end
+      end
+
+      def unregister_require_hook(registration)
+        registration.require_paths.each do |path|
+          require_hooks.delete path
+        end
+      end
+
+      private
+
+      def require_hooks
+        @require_hooks ||= {}
+      end
+    end
+  end
+end
+
+module Kernel
+  alias require_without_mn require
+
+  def require(name)
+    ret = require_without_mn(name)
+
+    # rubocop:disable Lint/RescueException
+    begin
+      ::Mnemosyne::Probes.require_hook(name)
+
+      # rubocop:disable Lint/HandleExceptions
+    rescue Exception
+    end
+
+    ret
+  end
+end

data/lib/mnemosyne/railtie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'rails'
+
+module Mnemosyne
+  class Railtie < ::Rails::Railtie
+    initializer 'mnemosyne.initialize' do |app|
+      config = app.config_for('mnemosyne')
+
+      config['application'] ||= app.class.name.underscore.titleize
+
+      # config['logger']  = Rails.logger
+      config['enabled'] ||= config.key?('server')
+
+      config = ::Mnemosyne::Config.new(config)
+
+      if config.enabled?
+        ::Mnemosyne::Instrumenter.start!(config)
+
+        app.middleware.insert 0, ::Mnemosyne::Middleware::Rack
+      else
+        config.logger.warn '[MNEMOSYNE] Instrumenter not enabled.'
+      end
+    end
+  end
+end

data/lib/mnemosyne/span.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  class Span
+    attr_reader :uuid, :name, :start, :finish, :meta
+
+    def initialize(name, start: false, finish: false, meta: {})
+      @name = name
+      @meta = meta
+      @uuid = ::SecureRandom.uuid
+
+      @start  = start
+      @finish = finish
+    end
+
+    def start!
+      @start = ::Mnemosyne::Clock.tick
+      self
+    end
+
+    def finish!
+      @finish = ::Mnemosyne::Clock.tick
+      self
+    end
+
+    def serialize
+      {
+        uuid: uuid,
+        name: name,
+        start: start,
+        stop: finish,
+        meta: meta
+      }
+    end
+  end
+end

data/lib/mnemosyne/trace.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  class Trace < Span
+    attr_reader :uuid, :transaction, :origin
+
+    def initialize(instrumenter, name, transaction: nil, origin: nil)
+      super name
+
+      @uuid = ::SecureRandom.uuid
+      @span = []
+
+      @origin      = origin
+      @transaction = transaction
+
+      @instrumenter = instrumenter
+    end
+
+    def <<(span)
+      @span << span
+    end
+
+    def submit
+      finish! unless finish
+
+      @instrumenter.submit self
+    end
+
+    def release
+      @instrumenter.release self
+    end
+
+    def serialize
+      {
+        uuid: uuid,
+        origin: origin,
+        transaction: transaction,
+        name: name,
+        start: start,
+        stop: finish,
+        meta: meta,
+        span: @span.map(&:serialize)
+      }
+    end
+  end
+end

data/lib/mnemosyne/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Mnemosyne
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    STAGE = nil
+
+    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.')
+
+    def self.to_s
+      STRING
+    end
+  end
+end

data/lib/mnemosyne.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require 'mnemosyne/version'
+
+require 'active_support'
+require 'active_support/notifications'
+
+module Mnemosyne
+  require 'mnemosyne/global'
+  extend Global
+
+  require 'mnemosyne/clock'
+  require 'mnemosyne/span'
+  require 'mnemosyne/trace'
+
+  require 'mnemosyne/config'
+  require 'mnemosyne/client'
+  require 'mnemosyne/instrumenter'
+
+  require 'mnemosyne/probe'
+  require 'mnemosyne/probes'
+
+  module Probes
+    require 'mnemosyne/probes/mnemosyne/tracer'
+
+    require 'mnemosyne/probes/acfs/request'
+    require 'mnemosyne/probes/action_controller/process_action'
+    require 'mnemosyne/probes/action_controller/renderers'
+    require 'mnemosyne/probes/action_view/render_partial'
+    require 'mnemosyne/probes/action_view/render_template'
+    require 'mnemosyne/probes/active_record/query'
+    require 'mnemosyne/probes/grape/endpoint_render'
+    require 'mnemosyne/probes/grape/endpoint_run'
+    require 'mnemosyne/probes/grape/endpoint_run_filters'
+    require 'mnemosyne/probes/responder/respond'
+    require 'mnemosyne/probes/restify/em'
+    require 'mnemosyne/probes/restify/typhoeus'
+  end
+
+  module Middleware
+    require 'mnemosyne/middleware/rack'
+  end
+
+  require 'mnemosyne/railtie' if defined?(Rails)
+end

data/mnemosyne-ruby.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mnemosyne/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mnemosyne-ruby'
+  spec.version       = Mnemosyne::VERSION
+  spec.authors       = ['Jan Graichen']
+  spec.email         = ['jgraichen@altimos.de']
+
+  spec.summary       = 'Ruby/Rails client for Mnemosynce'
+  spec.homepage      = 'http://github.com/jgraichen/mnemosyne-ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject {|f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^exe/}) {|f| File.basename(f) }
+  spec.require_paths = %w(lib)
+
+  spec.add_runtime_dependency 'bunny'
+  spec.add_runtime_dependency 'activesupport', '>= 4'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'timecop', '~> 0.8.0'
+end