influx_reporter 1.0.0

data/lib/influx_reporter/tasks.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+namespace :influx_reporter do
+  desc 'Notify InfluxReporter of a release'
+  task release: :environment do
+    unless rev = ENV['REV']
+      puts "Please specify a revision in an env variable\n" \
+           'eg. REV=abc123 rake influx_reporter:release'
+      exit 1
+    end
+
+    # empty env means dev
+    ENV['RAILS_ENV'] ||= 'development'
+
+    # log to STDOUT
+    InfluxReporter::Client.inst.config.logger = Logger.new STDOUT
+
+    unless InfluxReporter.release({
+                                      rev: rev,
+                                      branch: ENV['BRANCH'],
+                                      status: 'completed'
+                                  }, inline: true)
+      exit 1 # release returned nil
+    end
+  end
+
+  task deployment: :release
+end

data/lib/influx_reporter/trace.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/util'
+
+module InfluxReporter
+  class Trace
+    DEFAULT_KIND = 'code.custom'
+
+    def initialize(transaction, signature, kind = nil, parents = [], extra = nil)
+      @transaction = transaction
+      @signature = signature
+      @kind = kind || DEFAULT_KIND
+      @parents = parents || []
+      @extra = extra || {}
+
+      @timestamp = Util.nanos
+    end
+
+    attr_accessor :signature, :kind, :parents, :extra
+    attr_reader :transaction, :timestamp, :duration, :relative_start, :start_time
+
+    def start(relative_to)
+      @start_time = Util.nanos
+      @relative_start = start_time - relative_to
+
+      self
+    end
+
+    def done(ms = Util.nanos)
+      @duration = ms - start_time
+
+      self
+    end
+
+    def done?
+      !!duration
+    end
+
+    def running?
+      !done?
+    end
+
+    def inspect
+      info = %w[signature kind parents extra timestamp duration relative_start]
+      "<Trace #{info.map { |m| "#{m}:#{send(m).inspect}" }.join(' ')}>"
+    end
+  end
+end

data/lib/influx_reporter/trace_helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module TraceHelpers
+    module ClassMethods
+      def trace_class_method(method, signature, kind)
+        __trace_method_on(singleton_class, method, signature, kind)
+      end
+
+      private
+
+      def __trace_method_on(klass, method, signature, kind)
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias :"__without_opb_#{method}" :"#{method}"
+
+          def #{method}(*args, &block)
+            InfluxReporter.trace "#{signature}", "#{kind}" do
+              __without_opb_#{method}(*args, &block)
+            end
+          end
+        RUBY
+      end
+    end
+
+    def self.included(kls)
+      kls.class_eval do
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/influx_reporter/transaction.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/util'
+
+module InfluxReporter
+  class Transaction
+    ROOT_TRACE_NAME = 'transaction'
+
+    # @param client [InfluxReporter::Client]
+    # @param endpoint [String]
+    # @param kind [String]
+    # @param result [Integer]
+    def initialize(client, endpoint, kind = 'code.custom', result = nil)
+      @client = client
+      @config = client.config if client.respond_to?(:config)
+      @endpoint = endpoint
+      @kind = kind
+      @result = result
+
+      @timestamp = Util.nanos
+
+      @root_trace = Trace.new(self, ROOT_TRACE_NAME, ROOT_TRACE_NAME)
+      @traces = [@root_trace]
+      @notifications = []
+
+      @start_time = Util.nanos
+      @root_trace.start @start_time
+    end
+
+    attr_accessor :endpoint, :kind, :result, :duration
+    attr_reader :timestamp, :start_time, :traces, :notifications, :root_trace, :config
+
+    def release
+      @client.current_transaction = nil
+    end
+
+    def done(result = nil)
+      @result = result
+
+      @root_trace.done Util.nanos
+      @duration = @root_trace.duration
+
+      self
+    end
+
+    def done?
+      @root_trace.done?
+    end
+
+    def submit(result = nil)
+      done result
+
+      release
+
+      @client.submit_transaction self
+
+      self
+    end
+
+    def trace(signature, kind = nil, extra = nil)
+      trace = Trace.new(self, signature, kind, running_traces, extra)
+
+      rel_time = current_offset
+
+      traces << trace
+
+      trace.start rel_time
+
+      return trace unless block_given?
+
+      begin
+        result = yield trace
+      ensure
+        trace.done
+      end
+
+      result
+    end
+
+    def extra_tags
+      @root_trace.extra[:tags] ||= {}
+      yield @root_trace.extra[:tags]
+    end
+
+    def extra_values
+      @root_trace.extra[:values] ||= {}
+      yield @root_trace.extra[:values]
+    end
+
+    def running_traces
+      traces.select(&:running?)
+    end
+
+    def current_trace
+      traces.reverse.find(&:running?)
+    end
+
+    def current_offset
+      if curr = current_trace
+        return curr.start_time
+      end
+
+      start_time
+    end
+
+    def inspect
+      info = %w[endpoint kind result duration timestamp start_time]
+      <<~TEXT
+        <Transaction #{info.map { |m| "#{m}:#{send(m).inspect}" }.join(' ')}>
+          #{traces.map(&:inspect).join("\n  ")}"
+      TEXT
+    end
+  end
+end

data/lib/influx_reporter/util.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  module Util
+    def self.nearest_minute
+      now = Time.now.utc
+      now - now.to_i % 60
+    end
+
+    def self.nanos
+      now = Time.now.utc
+      now.to_i * 1_000_000_000 + now.nsec
+    end
+  end
+
+  require 'influx_reporter/util/inspector'
+end

data/lib/influx_reporter/util/constantize.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Util
+    # From https://github.com/rails/rails/blob/861b70e92f4a1fc0e465ffcf2ee62680519c8f6f/activesupport/lib/active_support/inflector/methods.rb#L249
+    #
+    # Tries to find a constant with the name specified in the argument string.
+    #
+    #   'Module'.constantize     # => Module
+    #   'Test::Unit'.constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C               # => 'inside'
+    #     'C'.constantize # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def self.constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/util/inspector.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Util
+    class Inspector
+      DEFAULTS = {
+          width: 120
+      }.freeze
+
+      NEWLINE = "\n"
+      SPACE = ' '
+
+      def initialize(config = {})
+        @config = DEFAULTS.merge(config)
+      end
+
+      def ms(nanos)
+        nanos.to_f / 1_000_000
+      end
+
+      def transaction(transaction, opts = {})
+        w = @config[:width].to_f
+        f = w / ms(transaction.duration)
+
+        traces = transaction.traces
+
+        traces = traces.each_with_object([]) do |trace, state|
+          descriptions = [
+            "#{trace.signature} - #{trace.kind}",
+            "transaction:#{trace.transaction.endpoint}"
+          ]
+
+          if opts[:include_parents]
+            descriptions << "parents:#{trace.parents.map(&:signature).join(',')}"
+          end
+
+          descriptions << "duration:#{ms trace.duration}ms - rel:#{ms trace.relative_start}ms"
+
+          start_diff = ms(trace.start_time) - ms(transaction.start_time)
+          indent = (start_diff.floor * f).to_i
+
+          longest_desc_length = descriptions.map(&:length).max
+          desc_indent = [[indent, w - longest_desc_length].min, 0].max
+
+          lines = descriptions.map do |desc|
+            "#{SPACE * desc_indent}#{desc}"
+          end
+
+          if trace.duration
+            span = (ms(trace.duration) * f).ceil.to_i
+            lines << "#{SPACE * indent}+#{'-' * [(span - 2), 0].max}+"
+          else
+            lines << "#{SPACE * indent}UNFINISHED"
+          end
+
+          state << lines.join("\n")
+        end.join("\n")
+
+        <<-STR.gsub(/^\s{8}/, '')
+        \n#{'=' * w.to_i}
+        #{transaction.endpoint} - kind:#{transaction.kind} - #{transaction.duration.to_f / 1_000_000}ms
+        +#{'-' * (w.to_i - 2)}+
+        #{traces}
+        STR
+      rescue => e
+        puts e
+        puts e.backtrace.join("\n")
+        transaction.inspect
+      end
+    end
+  end
+end

data/lib/influx_reporter/util/timestamp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Util
+    module Timestamp
+      def formatted_timestamp(t = Time.now)
+        format('%d%09d', t.to_i, t.nsec).to_i
+      end
+    end
+  end
+end

data/lib/influx_reporter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  VERSION = '1.0.0'
+end

data/lib/influx_reporter/worker.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  class Worker
+    include Logging
+
+    class PostRequest < Struct.new(:path, :data)
+      # require all parameters
+      def initialize(path, data)
+        super(path, data)
+      end
+    end
+
+    class StopMessage; end
+
+    def initialize(config, queue, influx_client)
+      @config = config
+      @queue = queue
+      @influx_client = influx_client
+    end
+
+    attr_reader :config
+
+    def run
+      loop do
+        while action = @queue.pop
+          case action
+            when PostRequest
+              process_request action
+            when StopMessage
+              Thread.exit
+            else
+              raise Error, "Unknown entity in worker queue: #{action.inspect}"
+          end
+        end
+      end
+    end
+
+    private
+
+    def process_request(req)
+      unless config.validate!
+        info 'Invalid config - Skipping posting to influxdb'
+        return
+      end
+
+      begin
+        @influx_client.post(req.path, req.data)
+      rescue => e
+        fatal "Failed POST: #{e.inspect}"
+        debug e.backtrace.join("\n")
+      end
+    end
+    end
+end