sapience 0.1.1

data/lib/sapience/sapience.rb

@@ -0,0 +1,357 @@
+require "concurrent"
+require "socket"
+
+# Example:
+#
+# Sapience.configure do |config|
+#   config.default_level   = ENV.fetch('SAPIENCE_DEFAULT_LEVEL') { :info }.to_sym
+#   config.backtrace_level = ENV.fetch('SAPIENCE_BACKTRACE_LEVEL') { :info }.to_sym
+#   config.application     = 'TestApplication'
+#   config.host            = ENV.fetch('SAPIENCE_HOST', nil)
+#   config.ap_options      = { multiline: false }
+#   config.appenders       = [
+#     { file: { io: STDOUT, formatter: :color } },
+#     { statsd: { url: 'udp://localhost:2222' } },
+#     { sentry: { dsn: 'ASDFASDF' } },
+#   ]
+# end
+
+# rubocop:disable ClassVars
+module Sapience
+  # 1. Have a default configuration
+  # 2. Configure Sapience (Sapience.configure { |c| c.configuration = {} })
+  # 3. Use configuration for rails
+  # 4. Use configuration for grape
+
+  # Logging levels in order of most detailed to most severe
+  LEVELS = [:trace, :debug, :info, :warn, :error, :fatal]
+
+  def self.config
+    @@config ||= Configuration.new
+  end
+
+  def self.configure
+    yield @@config
+
+    config.appenders.each do |appender|
+      appender.each do |name, options|
+        add_appender(name, options)
+      end
+    end
+  end
+
+  # Return a logger for the supplied class or class_name
+  def self.[](klass)
+    Sapience::Logger.new(klass)
+  end
+
+  # Add a new logging appender as a new destination for all log messages
+  # emitted from Sapience
+  #
+  # Appenders will be written to in the order that they are added
+  #
+  # If a block is supplied then it will be used to customize the format
+  # of the messages sent to that appender. See Sapience::Logger.new for
+  # more information on custom formatters
+  #
+  # Parameters
+  #   file_name: [String]
+  #     File name to write log messages to.
+  #
+  #   Or,
+  #   io: [IO]
+  #     An IO Stream to log to.
+  #     For example STDOUT, STDERR, etc.
+  #
+  #   Or,
+  #   appender: [Symbol|Sapience::Subscriber]
+  #     A symbol identifying the appender to create.
+  #     For example:
+  #       :bugsnag, :elasticsearch, :graylog, :http, :mongodb, :new_relic, :splunk_http, :syslog, :wrapper
+  #          Or,
+  #     An instance of an appender derived from Sapience::Subscriber
+  #     For example:
+  #       Sapience::Appender::Http.new(url: 'http://localhost:8088/path')
+  #
+  #   Or,
+  #   logger: [Logger|Log4r]
+  #     An instance of a Logger or a Log4r logger.
+  #
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: Sapience.config.default_level
+  #
+  #   formatter: [Symbol|Object|Proc]
+  #     Any of the following symbol values: :default, :color, :json
+  #       Or,
+  #     An instance of a class that implements #call
+  #       Or,
+  #     A Proc to be used to format the output from this appender
+  #     Default: :default
+  #
+  #   filter: [Regexp|Proc]
+  #     RegExp: Only include log messages where the class name matches the supplied.
+  #     regular expression. All other messages will be ignored.
+  #     Proc: Only include log messages where the supplied Proc returns true
+  #           The Proc must return true or false.
+  #
+  # Examples:
+  #
+  #   # Send all logging output to Standard Out (Screen)
+  #   Sapience.add_appender(:file, io: STDOUT)
+  #
+  #   # Send all logging output to a file
+  #   Sapience.add_appender(:file, file_name: 'logfile.log')
+  #
+  #   # Send all logging output to a file and only :info and above to standard output
+  #   Sapience.add_appender(:file, file_name: 'logfile.log')
+  #   Sapience.add_appender(:file, io: STDOUT, level: :info)
+  #
+  # Log to log4r, Logger, etc.:
+  #
+  #   # Send logging output to an existing logger
+  #   require 'logger'
+  #   require 'sapience'
+  #
+  #   # Built-in Ruby logger
+  #   log = Logger.new(STDOUT)
+  #   log.level = Logger::DEBUG
+  #
+  #   Sapience.config.default_level = :debug
+  #   Sapience.add_appender(:wrapper, logger: log)
+  #
+  #   logger = Sapience['Example']
+  #   logger.info "Hello World"
+  #   logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')
+  def self.add_appender(appender, options, _deprecated_level = nil, &block)
+    fail ArgumentError, "options should be a hash" unless options.is_a?(Hash)
+    appender_class = constantize_symbol(appender)
+    appender       = appender_class.new(options)
+    @@appenders << appender
+
+    # Start appender thread if it is not already running
+    Sapience::Logger.start_appender_thread
+    Sapience::Logger.logger = appender if appender.is_a?(Sapience::Appender::File)
+    appender
+  end
+
+  # Remove an existing appender
+  # Currently only supports appender instances
+  def self.remove_appender(appender)
+    @@appenders.delete(appender)
+  end
+
+  # Returns [Sapience::Subscriber] a copy of the list of active
+  # appenders for debugging etc.
+  # Use Sapience.add_appender and Sapience.remove_appender
+  # to manipulate the active appenders list
+  def self.appenders
+    @@appenders.clone
+  end
+
+  # Wait until all queued log messages have been written and flush all active
+  # appenders
+  def self.flush
+    Sapience::Logger.flush
+  end
+
+  # Close and flush all appenders
+  def self.close
+    Sapience::Logger.close
+  end
+
+  # After forking an active process call Sapience.reopen to re-open
+  # any open file handles etc to resources
+  #
+  # Note: Only appenders that implement the reopen method will be called
+  def self.reopen
+    @@appenders.each { |appender| appender.reopen if appender.respond_to?(:reopen) }
+    # After a fork the appender thread is not running, start it if it is not running
+    Sapience::Logger.start_appender_thread
+  end
+
+  # Add signal handlers for Sapience
+  #
+  # Two signal handlers will be registered by default:
+  #
+  # 1. Changing the log_level:
+  #
+  #   The log level can be changed without restarting the process by sending the
+  #   log_level_signal, which by default is 'USR2'
+  #
+  #   When the log_level_signal is raised on this process, the global default log level
+  #   rotates through the following log levels in the following order, starting
+  #   from the current global default level:
+  #     :warn, :info, :debug, :trace
+  #
+  #   If the current level is :trace it wraps around back to :warn
+  #
+  # 2. Logging a Ruby thread dump
+  #
+  #   When the signal is raised on this process, Sapience will write the list
+  #   of threads to the log file, along with their back-traces when available
+  #
+  #   It is recommended to name any threads you create in the application, by
+  #   calling the following from within the thread itself:
+  #      Thread.current.name = 'My Worker'
+  #
+  #
+  # Note:
+  #   To only register one of the signal handlers, set the other to nil
+  # rubocop:disable AbcSize, CyclomaticComplexity, PerceivedComplexity
+  def self.add_signal_handler(log_level_signal = "USR2", thread_dump_signal = "TTIN", _gc_log_microseconds = 100_000)
+    Signal.trap(log_level_signal) do
+      index     = (default_level == :trace) ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
+      new_level = LEVELS[index - 1]
+      self["Sapience"].warn "Changed global default log level to #{new_level.inspect}"
+      self.default_level = new_level
+    end if log_level_signal
+
+    Signal.trap(thread_dump_signal) do
+      logger = Sapience["Thread Dump"]
+      Thread.list.each do |thread|
+        next if thread == Thread.current
+        message = thread.name
+        if (backtrace = thread.backtrace)
+          message += "\n"
+          message << backtrace.join("\n")
+        end
+        tags = thread[:sapience_tags]
+        tags = tags.nil? ? [] : tags.clone
+        logger.tagged(tags) { logger.warn(message) }
+      end
+    end if thread_dump_signal
+
+    true
+  end
+
+  # rubocop:enable AbcSize, CyclomaticComplexity, PerceivedComplexity
+
+  # If the tag being supplied is definitely a string then this fast
+  # tag api can be used for short lived tags
+  def self.fast_tag(tag)
+    (Thread.current[:sapience_tags] ||= []) << tag
+    yield
+  ensure
+    Thread.current[:sapience_tags].pop
+  end
+
+  # Add the supplied named tags to the list of tags to log for this thread whilst
+  # the supplied block is active.
+  #
+  # Returns result of block
+  #
+  # Example:
+  def self.named_tags(tag)
+    (Thread.current[:sapience_tags] ||= []) << tag
+    yield
+  ensure
+    Thread.current[:sapience_tags].pop
+  end
+
+  # Add the supplied tags to the list of tags to log for this thread whilst
+  # the supplied block is active.
+  # Returns result of block
+  def self.tagged(*tags)
+    new_tags = push_tags(*tags)
+    yield self
+  ensure
+    pop_tags(new_tags.size)
+  end
+
+  # Returns a copy of the [Array] of [String] tags currently active for this thread
+  # Returns nil if no tags are set
+  def self.tags
+    # Since tags are stored on a per thread basis this list is thread-safe
+    t = Thread.current[:sapience_tags]
+    t.nil? ? [] : t.clone
+  end
+
+  # Add tags to the current scope
+  # Returns the list of tags pushed after flattening them out and removing blanks
+  def self.push_tags(*tags)
+    # Need to flatten and reject empties to support calls from Rails 4
+    new_tags                       = tags.flatten.collect(&:to_s).reject(&:empty?)
+    t                              = Thread.current[:sapience_tags]
+    Thread.current[:sapience_tags] = t.nil? ? new_tags : t.concat(new_tags)
+    new_tags
+  end
+
+  # Remove specified number of tags from the current tag list
+  def self.pop_tags(quantity = 1)
+    t = Thread.current[:sapience_tags]
+    t.pop(quantity) unless t.nil?
+  end
+
+  # Silence noisy log levels by changing the default_level within the block
+  #
+  # This setting is thread-safe and only applies to the current thread
+  #
+  # Any threads spawned within the block will not be affected by this setting
+  #
+  # #silence can be used to both raise and lower the log level within
+  # the supplied block.
+  #
+  # Example:
+  #
+  #   # Perform trace level logging within the block when the default is higher
+  #   Sapience.config.default_level = :info
+  #
+  #   logger.debug 'this will _not_ be logged'
+  #
+  #   Sapience.silence(:trace) do
+  #     logger.debug "this will be logged"
+  #   end
+  #
+  # Parameters
+  #   new_level
+  #     The new log level to apply within the block
+  #     Default: :error
+  #
+  # Example:
+  #   # Silence all logging for this thread below :error level
+  #   Sapience.silence do
+  #     logger.info "this will _not_ be logged"
+  #     logger.warn "this neither"
+  #     logger.error "but errors will be logged"
+  #   end
+  #
+  # Note:
+  #   #silence does not affect any loggers which have had their log level set
+  #   explicitly. I.e. That do not rely on the global default level
+  def self.silence(new_level = :error)
+    current_index                     = Thread.current[:sapience_silence]
+    Thread.current[:sapience_silence] = Sapience.config.level_to_index(new_level)
+    yield
+  ensure
+    Thread.current[:sapience_silence] = current_index
+  end
+
+  private
+
+  @@appenders = Concurrent::Array.new
+
+  def self.constantize_symbol(symbol, namespace = "Sapience::Appender")
+    klass = "#{namespace}::#{camelize(symbol.to_s)}"
+    begin
+      if RUBY_VERSION.to_i >= 2
+        Object.const_get(klass)
+      else
+        klass.split("::").inject(Object) { |o, name| o.const_get(name) } # rubocop:disable SingleLineBlockParams
+      end
+    rescue NameError
+      raise(ArgumentError, "Could not convert symbol: #{symbol} to a class in: #{namespace}. Looking for: #{klass}")
+    end
+  end
+
+  # Borrow from Rails, when not running Rails
+  def self.camelize(term) # rubocop:disable AbcSize
+    string = term.to_s
+    string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+      "#{Regexp.last_match[1]}#{inflections.acronyms[Regexp.last_match[2]] || Regexp.last_match[2].capitalize}"
+    end
+    string.gsub!("/".freeze, "::".freeze)
+    string
+  end
+end

data/lib/sapience/subscriber.rb

@@ -0,0 +1,127 @@
+# Abstract Subscriber
+#
+#   Abstract base class for appender and metrics subscribers.
+module Sapience
+  class Subscriber < Sapience::Base
+    # Every logger has its own formatter
+    attr_accessor :formatter
+    attr_writer :application, :host
+
+    # Returns the current log level if set, otherwise it logs everything it receives
+    def level
+      @level || :trace
+    end
+
+    # A subscriber should implement flush if it can.
+    def flush
+      # NOOP
+    end
+
+    # A subscriber should implement close if it can.
+    def close
+      # NOOP
+    end
+
+    # Returns [Sapience::Formatters::Default] formatter default for this subscriber
+    def default_formatter
+      Sapience::Formatters::Default.new
+    end
+
+    # Allow application name to be set globally or per subscriber
+    def application
+      @application || Sapience.config.application
+    end
+
+    # Allow host name to be set globally or per subscriber
+    def host
+      @host || Sapience.config.host
+    end
+
+    private
+
+    # Initializer for Abstract Class Sapience::Subscriber
+    #
+    # Parameters
+    #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+    #     Override the log level for this subscriber.
+    #     Default: :error
+    #
+    #   formatter: [Object|Proc]
+    #     An instance of a class that implements #call, or a Proc to be used to format
+    #     the output from this subscriber
+    #     Default: Use the built-in formatter (See: #call)
+    #
+    #   filter: [Regexp|Proc]
+    #     RegExp: Only include log messages where the class name matches the supplied.
+    #     regular expression. All other messages will be ignored.
+    #     Proc: Only include log messages where the supplied Proc returns true
+    #           The Proc must return true or false.
+    #
+    #   host: [String]
+    #     Name of this host to appear in log messages.
+    #     Default: Sapience.config.host
+    #
+    #   application: [String]
+    #     Name of this application to appear in log messages.
+    #     Default: Sapience.config.application
+    def initialize(options = {}, &block)
+      # Backward compatibility
+      options      = { level: options } unless options.is_a?(Hash)
+      options      = options.dup
+      level        = options.delete(:level)
+      filter       = options.delete(:filter)
+      @formatter   = extract_formatter(options.delete(:formatter), &block)
+      @application = options.delete(:application)
+      @host        = options.delete(:host)
+      fail(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
+
+      # Subscribers don't take a class name, so use this class name if an subscriber
+      # is logged to directly
+      super(self.class, level, filter)
+    end
+
+    # Return the level index for fast comparisons
+    # Returns the lowest level index if the level has not been explicitly
+    # set for this instance
+    def level_index
+      @level_index || 0
+    end
+
+    # Return formatter that responds to call
+    # Supports formatter supplied as:
+    # - Symbol
+    # - Hash ( Symbol => { options })
+    # - Instance of any of Sapience::Formatters
+    # - Proc
+    # - Any object that responds to :call
+    # - If none of the above apply, then the supplied block is returned as the formatter.
+    # - Otherwise an instance of the default formatter is returned.
+    def extract_formatter(formatter, &block) # rubocop:disable Metrics/CyclomaticComplexity
+      case
+      when formatter.is_a?(Symbol)
+        Sapience.constantize_symbol(formatter, "Sapience::Formatters").new
+      when formatter.is_a?(Hash) && formatter.size > 0
+        fmt, options = formatter.first
+        Sapience.constantize_symbol(fmt.to_sym, "Sapience::Formatters").new(options)
+      when formatter.respond_to?(:call)
+        formatter
+      when block
+        block
+      when respond_to?(:call)
+        self
+      else
+        default_formatter
+      end
+    end
+
+    SUBSCRIBER_OPTIONS = [:level, :formatter, :filter, :application, :host].freeze
+
+    # Returns [Hash] the subscriber common options from the supplied Hash
+    def extract_subscriber_options!(options)
+      subscriber_options = {}
+      SUBSCRIBER_OPTIONS.each { |key| subscriber_options[key] = options.delete(key) if options.key?(key) }
+      subscriber_options
+    end
+
+  end
+end

data/lib/sapience/version.rb

@@ -0,0 +1,3 @@
+module Sapience
+  VERSION = "0.1.1"
+end

data/lib/sapience.rb

@@ -0,0 +1,35 @@
+require "sapience/version"
+require "sapience/sapience"
+
+# @formatter:off
+
+require "sapience/concerns/compatibility"
+
+require "sapience/formatters/base"
+require "sapience/formatters/raw"
+require "sapience/formatters/default"
+require "sapience/formatters/color"
+require "sapience/formatters/json"
+
+require "sapience/configuration"
+require "sapience/ansi_colors"
+require "sapience/core_ext/thread"
+require "sapience/base"
+require "sapience/log"
+require "sapience/logger"
+require "sapience/loggable"
+require "sapience/subscriber"
+
+require "sapience/appender/file"
+require "sapience/appender/sentry"
+require "sapience/appender/wrapper"
+require "sapience/appender/statsd"
+
+# @formatter:on
+
+# Close and flush all appenders at exit, waiting for outstanding messages on the queue
+# to be written first
+at_exit do
+  # Cannot call #close since test frameworks use at_exit to run loaded tests
+  Sapience.flush
+end

data/sapience.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sapience/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sapience"
+  spec.version       = Sapience::VERSION
+  spec.authors       = ["Mikael Henriksson", "Alex Malkov"]
+  spec.email         = ["mika@reevoo.com", "alex.malkov@reevoo.com"]
+
+  spec.summary       = "Write a short summary, because Rubygems requires one."
+  spec.description   = "Write a longer description or delete this line."
+  spec.homepage      = "https://sapience.github.io"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    fail "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(/^(test|spec|features)\//) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "concurrent-ruby"
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "reevoocop"
+  spec.add_development_dependency "fuubar"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-json"
+  spec.add_development_dependency "rspec-its"
+end

data/test_app/.gitignore

@@ -0,0 +1,42 @@
+*.rbc
+capybara-*.html
+.rspec
+/log
+/tmp
+/db/*.sqlite3
+/db/*.sqlite3-journal
+/public/system
+/coverage/
+/spec/tmp
+**.orig
+rerun.txt
+pickle-email-*.html
+
+# TODO Comment out these rules if you are OK with secrets being uploaded to the repo
+config/initializers/secret_token.rb
+config/secrets.yml
+
+# dotenv
+# TODO Comment out this rule if environment variables can be committed
+.env
+
+## Environment normalization:
+/.bundle
+/vendor/bundle
+
+# these should all be checked in to normalize the environment:
+# Gemfile.lock, .ruby-version, .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# if using bower-rails ignore default bower_components path bower.json files
+/vendor/assets/bower_components
+*.bowerrc
+bower.json
+
+# Ignore pow environment settings
+.powenv
+
+# Ignore Byebug command history file.
+.byebug_history

data/test_app/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/test_app/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/test_app/Gemfile

@@ -0,0 +1,36 @@
+source "https://rubygems.org"
+
+
+# Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
+gem "rails", "~> 5.0.0"
+# Use sqlite3 as the database for Active Record
+gem "sqlite3"
+# Use Puma as the app server
+gem "puma", "~> 3.0"
+# Use Redis adapter to run Action Cable in production
+# gem 'redis', '~> 3.0'
+# Use ActiveModel has_secure_password
+# gem 'bcrypt', '~> 3.1.7'
+
+# Use Capistrano for deployment
+# gem 'capistrano-rails', group: :development
+gem "sapience", path: "../"
+gem "sentry-raven"
+gem "statsd-ruby"
+
+group :development, :test do
+  # Call 'byebug' anywhere in the code to stop execution and get a debugger console
+  gem "byebug", platform: :mri
+  # gem "pry-nav"
+  gem "pry-byebug"
+  gem "rspec-rails"
+end
+
+group :development do
+  # Access an IRB console on exception pages or by using <%= console %> anywhere in the code.
+  gem "web-console"
+  gem "listen", "~> 3.0.5"
+end
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem "tzinfo-data", platforms: [:mingw, :mswin, :x64_mingw, :jruby]

data/test_app/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

data/test_app/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/test_app/app/assets/config/manifest.js

@@ -0,0 +1,2 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css

data/test_app/app/assets/javascripts/posts.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.