activetracker 0.4.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "activetracker"
+
+# 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/rails

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/active_tracker/engine', __dir__)
+APP_PATH = File.expand_path('../test/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require "rails"
+# Pick the frameworks you want:
+require "active_model/railtie"
+require "active_job/railtie"
+require "active_record/railtie"
+require "active_storage/engine"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+# require "action_cable/engine"
+require "sprockets/railtie"
+require "rails/test_unit/railtie"
+require 'rails/engine/commands'

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/doc/logo.md

@@ -0,0 +1,11 @@
+# Logo
+
+The icon used as part of ActiveTracker's logo was a free/promotional order from Logofound.com (order #24181, September 27, 2019).
+
+When used as part of referring to ActiveTracker, it should not be used in any way implying any form of endorsement.
+
+## Original SVG
+
+The SVG below is the one originally supplied to us, but run through [SVGOMG](https://jakearchibald.github.io/svgomg/) to optimise it
+
+<svg xmlns="http://www.w3.org/2000/svg" width="11in" height="816" viewBox="0 0 11000 8500" shape-rendering="geometricPrecision" text-rendering="geometricPrecision" image-rendering="optimizeQuality" fill-rule="evenodd" clip-rule="evenodd"><g fill="#333"><path d="M7361 4662c-55 403-243 764-517 1039-330 330-786 534-1289 534-146 0-289-17-425-50l-912 1502c-142 234-447 309-681 167s-309-447-167-681l895-1474c-329-330-532-785-532-1287 0-85 6-169 17-251 209 90 429 167 647 230v21c0 320 130 610 339 819 210 210 499 339 819 339s610-130 819-339c142-142 247-320 300-519 222-3 441-17 652-45l34-5z" fill-rule="nonzero"/><path d="M4658 1194c315 0 478 330 975 330s696-330 1059-330c239 0 381 202 434 434 73 316 135 744 306 1225 111 45 216 93 312 141 479 243 769 528 726 794-46 282-454 481-1081 564-637 85-1469 47-2310-128-810-169-1443-428-1811-701-347-257-456-524-273-745 172-207 575-343 1090-400 67-255 90-511 138-750 48-234 195-434 434-434zm2866 2305c-438 81-864 96-1305 71-398-22-820-77-1245-165-417-87-692-185-1039-327-154-63-116-123-82-177 46-75 96-165 137-245 873 293 2373 625 3494 397 46 102 100 209 138 313 19 54 39 107-98 132z"/></g></svg>

data/integration/generators/installer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+initializer "activetracker.rb" do
+  File.read(ActiveTracker::Engine.root.join("integration", "templates", "initializer.rb"))
+end
+
+route "ActiveTracker::Router.load"

data/integration/templates/initializer.rb

@@ -0,0 +1,32 @@
+# Which plugins are active. The full list installed by default is:
+#
+# ActiveTracker::Plugin::Request       # Entire request log, with response
+# ActiveTracker::Plugin::Query         # Queries performed with ms taken
+# ActiveTracker::Plugin::Exception     # When an exception is raised
+# ActiveTracker::Plugin::Schedule      # When a scheduled job is queued
+# ActiveTracker::Plugin::ActiveJob     # When a job is processed, with output
+# ActiveTracker::Plugin::ActionMail    # When an email is sent, with the body
+# ActiveTracker::Plugin::Event         # Random events triggered in the system
+
+ActiveTracker::Configuration.plugins = [
+  ActiveTracker::Plugin::Request,
+  ActiveTracker::Plugin::Query,
+  ActiveTracker::Plugin::Exception,
+]
+
+# You should change this to be your correct Redis URL
+ActiveTracker::Configuration.redis_url = "redis://localhost:6379/15"
+
+# By default ActiveTracker is mounted at /activetracker
+# if you'd like to change it, you can do so like this:
+# ActiveTracker::Configuration.mountpoint = "debugger"
+
+# If you want to authenticate requests to ActiveTracker with username and password
+# ActiveTracker::Configuration.authentication = "username:password"
+# or using a proc:
+# ActiveTracker::Configuration.authentication do
+#   false unless params[:password] == "password"
+# end
+
+# If you would like a particular number of items per page
+# ActiveTracker::Configuration.per_page = 20

data/lib/active_tracker.rb

@@ -0,0 +1,41 @@
+require "active_tracker/version"
+require "redis"
+
+module ActiveTracker
+  class Error < StandardError; end
+
+  def self.reset_connection
+    @redis = nil
+  end
+
+  def self.connection
+    if @redis
+      begin
+        @redis.ping
+      rescue
+        @redis = nil
+      end
+    end
+
+    @redis ||= Redis.new(url: ActiveTracker::Configuration.redis_url)
+
+    begin
+      @redis.ping
+    rescue
+      @redis = nil
+    end
+
+    @redis
+  rescue Errno::ECONNREFUSED, Redis::CannotConnectError
+    @redis = nil
+  end
+
+  def self.connection_offline?
+    offline = connection.nil?
+    Rails.logger.error("ActiveTracker: Redis is offline/unreachable") if offline
+    offline
+  end
+end
+
+require "active_tracker/configuration"
+require "active_tracker/engine"

data/lib/active_tracker/configuration.rb

@@ -0,0 +1,67 @@
+module ActiveTracker
+  class Configuration
+    def self.plugins
+      @@plugins ||= [
+        ActiveTracker::Plugin::Request,
+      ]
+      @@plugins
+    end
+
+    def self.plugins=(items)
+      items.each do |i|
+        if i.respond_to?(:register)
+          i.register
+        else
+          raise PluginInvalidError.new("#{i.name} doesn't correctly implement the ActiveTracker API")
+        end
+      end
+
+      @@plugins = items.dup
+    end
+
+    def self.redis_url
+      @@redis_url ||= "redis://localhost:6379/15"
+    end
+
+    def self.redis_url=(url)
+      unless url.start_with?("redis://")
+        raise PluginInvalidError.new("redis_url isn't a valid Redis URL - should begin with redis://")
+      end
+      @@redis_url = url
+    end
+
+    def self.mountpoint
+      @@mountpoint ||= "activetracker"
+    end
+
+    def self.root_path
+      "/#{mountpoint}"
+    end
+
+    def self.mountpoint=(path)
+      @@mountpoint = path
+    end
+
+    def self.per_page=(value)
+      @@per_page = value
+    end
+
+    def self.per_page
+      @@per_page ||= 20
+      @@per_page.to_i
+    end
+
+    def self.authentication(&block)
+      if block
+        @@authentication = block
+      end
+      @@authentication ||= nil
+    end
+
+    def self.authentication=(value)
+      @@authentication = value
+    end
+
+    class PluginInvalidError < ActiveTracker::Error ; end
+  end
+end

data/lib/active_tracker/engine.rb

@@ -0,0 +1,24 @@
+module ActiveTracker
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveTracker
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+
+    initializer 'active_tracker_helper.action_controller' do
+      ActiveSupport.on_load :action_controller do
+        helper ActiveTracker::ImagesHelper
+        helper ActiveTracker::ApplicationHelper
+        helper ActiveTracker::PaginationHelper
+        helper ActiveTracker::OutputHelper
+      end
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.fixture_replacement :factory_girl, dir: 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+
+    config.assets.precompile += %w(active_tracker_manifest active_tracker/active_tracker.js active_tracker/active_tracker.css)
+  end
+end

data/lib/active_tracker/exception_capturer.rb

@@ -0,0 +1,38 @@
+module ActiveTracker
+  class ExceptionCapturer
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+
+      response = @app.call(env)
+
+      framework_exception = env['action_dispatch.exception']
+      if framework_exception
+        record_exception(env, framework_exception)
+      end
+
+      response
+    rescue Exception => exception
+
+      record_exception(env, exception)
+      raise exception
+    end
+
+    def record_exception(env, exception)
+      if env['action_dispatch.backtrace_cleaner']
+        backtrace = env['action_dispatch.backtrace_cleaner'].filter(exception.backtrace)
+        backtrace = exception.backtrace if backtrace.blank?
+      else
+        backtrace = exception.backtrace
+      end
+      class_name = exception.class.name
+      message = exception.message
+      backtrace = backtrace || []
+
+      ActiveTracker::Plugin::Exception.exception_capture(class_name, message, backtrace)
+    end
+
+  end
+end

data/lib/active_tracker/model.rb

@@ -0,0 +1,153 @@
+require 'json'
+
+module ActiveTracker
+  class Model
+    PREFIX = "/ActiveTracker".freeze
+
+    def self.find(key)
+      return nil if ActiveTracker.connection_offline?
+
+      connection = ActiveTracker.connection
+      value = connection.get(key)
+      if value.nil?
+        raise NotFound.new("Couldn't find entry - #{key}")
+      else
+        if value.start_with?(PREFIX)
+          find(value)
+        else
+          self.new(key, value)
+        end
+      end
+    end
+
+    def self.delete(key)
+      ActiveTracker.connection.del(key)
+    end
+
+    def self.all(type, tags: {}, data_type: nil)
+      return [] if ActiveTracker.connection_offline?
+
+      keys = "#{PREFIX}/#{type}/"
+
+      keys += "*"
+
+      keys += tags.sort_by { |k,v| k.to_s }.map do |k,v|
+        "#{k}:#{CGI.escape(v.to_s)}"
+      end.join("*")
+
+      keys += "*" unless keys.end_with?("*")
+
+      if data_type
+        keys += "/#{data_type}"
+      end
+
+      connection = ActiveTracker.connection
+      result = connection.keys(keys).sort { |a,b| b <=> a }.map { |key| self.new(key, {}.to_json) }
+    end
+
+    def self.generate_key(type, log_time, tags, data_type)
+      key = PREFIX + "/#{type}/#{log_time}"
+      converted_tags = tags.sort_by { |k,v| k.to_s }.map {|k,v| "#{k}:#{CGI.escape(v.to_s)}"}
+      if converted_tags.any?
+        key = key + "/" + converted_tags.join("/")
+      end
+      key += "/#{data_type}"
+      key.gsub!(%r{/{2,}}, '/')
+      key
+    end
+
+    def self.save(type, data, tags: {}, data_type: nil, expiry: 7.days, log_at: Time.current)
+      return nil if ActiveTracker.connection_offline?
+
+      if log_at.respond_to?(:strftime)
+        log_time = log_at.strftime("%Y%m%d%H%M%S")
+      else
+        log_time = log_at
+      end
+      key = generate_key(type, log_time, tags, data_type)
+      value = data.to_json
+      connection = ActiveTracker.connection
+      connection.set(key, value)
+      connection.expire(key, expiry)
+      if tags[:id].present?
+        connection.set(tags[:id], key)
+        connection.expire(tags[:id], expiry)
+      end
+      key
+    end
+
+    def self.find_or_create(type, tags: {}, data_type: nil)
+      keys = all(type, tags: tags, data_type: data_type)
+      if keys.length > 0
+        obj = find(keys.first.key) rescue nil
+      end
+
+      if !obj
+        obj = new(generate_key(type, "-", tags, data_type), {}.to_json, false)
+      end
+      yield obj
+      obj.save
+    end
+
+    def self.paginate(items, page, per_page)
+      page = (page || 1).to_i
+
+      total = items.length
+      start_point = (page - 1) * per_page
+
+      items = items[start_point, per_page]
+
+      total_pages = total / per_page
+      total_pages += 1 if (total % per_page != 0)
+
+      window = []
+      window << page - 2 if page > 2
+      window << page - 1 if page > 1
+      window << page
+      window << page + 1 if (total_pages - page) > 0
+      window << page + 2 if (total_pages - page) > 1
+
+      [items, {total: total, total_pages: total_pages, page: page, window: window}]
+    end
+
+    def initialize(key, value, persisted = true)
+      @attrs = {key: key, persisted: persisted}
+      key.gsub!(/^A#{PREFIX}/, "")
+      parts = key.split("/")
+      _ = parts.shift # Starts with a /
+      _ = parts.shift # then comes PREFIX
+      @attrs[:type] = parts.shift
+      @attrs[:data_type] = parts.pop
+      t = parts.shift
+      @attrs[:log_at] = Time.parse(t) rescue t
+      @attrs[:tags] = {}
+      parts.sort.each do |part|
+        tag_name, tag_value = part.split(":")
+        if tag_name == "id"
+          @attrs[:id] = tag_value
+        else
+          @attrs[:tags][tag_name.to_sym] = CGI.unescape("#{tag_value}")
+        end
+      end
+      value = JSON.parse(value)
+      self.send("data=", value)
+      value.each do |key, value|
+        self.send("#{key}=", value)
+      end
+    end
+
+    def save
+      self.class.save(@attrs[:type], data, tags: {id: id}.merge(@attrs[:tags]), data_type: @attrs[:data_type], expiry: expiry, log_at: log_at)
+    end
+
+    def method_missing(name, value = nil)
+      if name.to_s.end_with?("=")
+        @attrs[name.to_s.gsub("=", "").to_sym] = value
+      else
+        @attrs[name]
+      end
+    end
+
+    class NotFound < ActiveTracker::Error ; end
+  end
+end

data/lib/active_tracker/output_capturer.rb

@@ -0,0 +1,37 @@
+module ActiveTracker
+  class OutputCapturer
+    def initialize(app)
+      @app         = app
+    end
+
+    def call(env)
+      start_time = Time.current
+      status, headers, response = @app.call(env)
+      [status, headers, response]
+    ensure
+      capture(response)
+      duration = (Time.current.to_f - start_time.to_f) * 1000
+      ActiveTracker::Plugin::Request.record_duration(duration)
+    end
+
+    def capture(response)
+      body = response.body rescue nil
+      unless body.is_a?(String)
+        body = body.to_a rescue [body.body] rescue "No body given"
+      end
+
+      if body.respond_to?(:each)
+        output = []
+        body.each do |line|
+          output << line
+        end
+        output = output.join("\n")
+      else
+        output = body.to_s
+      end
+
+      ActiveTracker::Plugin::Request.output_capture(output)
+    end
+
+  end
+end