added logs and metrics

Author: v-dolgishev

Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stackify.gemspec
+gemspec

Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    stackify-api-ruby (1.0.0)
+      activesupport (~> 4.1, >= 4.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.1.4)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    i18n (0.6.11)
+    json (1.8.1)
+    minitest (5.4.0)
+    rake (0.9.6)
+    thread_safe (0.3.4)
+    tzinfo (1.2.1)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  rake (~> 0)
+  stackify-api-ruby!

README.md

@@ -1,4 +1,157 @@
-stackify-api-ruby
-=================
+# Stackify
 
-Stackify API for Ruby
+Stackify Logs and Metrics API for Ruby
+
+
+Rails Installation
+------------------
+
+### Rails 3.x/4.x
+
+Add the stackify gem to your Gemfile. In Gemfile:
+
+    gem 'stackify-api-ruby'
+
+Run the bundle command to install it:
+
+    $ bundle
+
+Or install it manually:
+
+    $ gem install stackify-api-ruby
+
+After you install stackify-api-ruby you need to run the generator:
+
+    $ rails g stackify --api_key=your_api_key
+
+The generator creates a file under config/initializers/stackify.rb configuring stackify-api-ruby with your API key. You can change default settings there.
+
+Usage: Logging
+------------------
+
+### Rails Environment
+
+stackify-api-ruby starts working with start of Rails. Every occured error will be cought and sent to Stackify automatically. The same situation with logs - you just use the Rails logger as usual:
+
+    Rails.logger.info "Some log message"
+
+### Other Environment
+
+For using stackify-api-ruby gem within any Ruby application add to top of your main file:
+
+    require 'stackify-api-ruby'
+
+After that you need to make base configuration:
+
+    Stackify.setup do |config|
+      config.api_key = "your_api_key"
+      config.env = :development
+      config.app_name =  "Your's app name"
+      config.app_location =  "/somewhere/public"
+    end
+
+"api_key" - it's you key for Stackify. "app-location" - it's location of your application for Nginx/Apache(for Nginx it's value of 'root', for Apache it's value of 'DocumentRoot' at config files).
+
+Gem has 3 modes of work - "both", "logging", "metrics". Mode "both" turns on both parts of gem - logging and metrics.
+If you need ONLY logging or metrics use "logging" or "metrics" mode accordingly.
+
+    config.mode = :metrics
+
+You can set minimal level of logs, which should be caught by gem:
+
+    config.log_level = :error
+
+By default, gem sends logs to Stackify every 60 seconds, you can increase this value to higher if need:
+
+    config.send_interval = 60 #value in seconds, could not be less than 60 seconds
+
+All logs, errors, and metrics are queued within the gem and uploaded on a background thread. By default, the maximum amount of logs is 1,000 log items, you can decrease this value:
+
+    config.queue_max_size = 600
+
+To help prevent flooding the system there is a parameter - max amount of the same error per minute:
+
+    config.flood_limit = 100
+
+If you want to use proxy for sendig request, you can do it in such way:
+
+    config.with_proxy = true
+    config.proxy_host = "127.0.0.1"
+    config.proxy_port = "8118"
+    config.proxy_user = nil
+    config.proxy_pass = nil
+
+For logging own work stackify-api-rubystackify-api-rubygem uses such logger:
+
+    config.logger = Logger.new(File.join(Rails.root, "log", "stackify.log"))
+
+After set up of logs you should wrap up your logger:
+
+    logger = Logger.new('mylog.log')
+    logger = Stackify::LoggerProxy.new(logger)
+
+
+And last thing you need to do - call method "run":
+
+    Stackify.run #remember that this call is running in the background of your main script
+
+Usage: Metrics
+------------------
+
+There are four different types of metrics:
+
+- **Gauge**: Keeps track of the last value that was set in the current minute
+
+        Stackify::Metrics.set_gauge "MyCategory", "MyGauge", 100
+
+- **Counter**: Calculates the rate per minute
+
+        Stackify::Metrics.count "MyCategory", "MyCounter"
+
+- **Average**: Calculates the average of all values in the current minute
+
+        Stackify::Metrics.average "MyCategory", "AverageSpeed", 200
+
+- **Timer**: Calculates the average elapsed time for an operation in the current minute
+
+        t = Time.now
+        Stackify::Metrics.time "MyCategory", "ElapsedTime", t
+
+- **Counter and Timer**: Composite of the Counter and Timer metrics for convenience
+
+        t = Time.now
+        Stackify::Metrics.count_and_time "Metric", "CounterWithTime", t
+
+We can configure every metric with settings:
+
+        settings  = MetricSettings.new
+        settings.autoreport_zero_if_nothing_reported = true
+        # or
+        settings.autoreport_last_value_if_nothing_reported = true
+        Stackify::Metrics.set_gauge "MyCategory", "MyGauge", 100 , settings
+
+Note, "autoreport_last_value_if_nothing_reported" property has influence only on "average" metric.
+
+Also there are two methods for getting last values of metrics:
+
+- get_latest - return last value of certain metric
+
+    ``` Stackify::Metrics.get_latest "MyCategory", "MyCounter" ```
+
+- get_latest_all_metrics - return all values of existed metrics
+
+    ``` Stackify::Metrics.get_latest_all_metrics```
+
+## Requirements
+Ruby: 1.9/2.0/2.1
+
+Rails: 3.x/4.x
+
+Contributing
+------------------
+
+1. Fork it ( https://github.com/[my-github-username]/stackify/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

lib/generators/stackify/stackify_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/base'
+
+class StackifyGenerator < Rails::Generators::Base
+  source_root File.expand_path('../../stackify/templates', __FILE__)
+
+  class_option :api_key, type: :string, required: true
+
+  desc 'Creates a Stackify initializer'
+  def copy_initializer
+    template 'stackify.rb', 'config/initializers/stackify.rb'
+  end
+
+end

lib/generators/stackify/templates/stackify.rb

@@ -0,0 +1,17 @@
+Stackify.setup do |config|
+  config.api_key = '<%= options[:api_key] %>'
+  #config.mode = :both
+  #config.app_name =  "Your's app name"
+  #config.env = :development
+  #config.flood_limit = 100
+  #config.queue_max_size = 1000
+  #config.send_interval = 60 #sec
+  #config.log_level = :error
+  #config.logger = Logger.new(File.join(Rails.root, 'log', 'stackify.log'))
+  #config.logger.level = Logger::INFO
+  #config.with_proxy = false
+  #config.proxy_host = '127.0.0.1'
+  #config.proxy_port = '8118'
+  #config.proxy_user = nil
+  #config.proxy_pass = nil
+end

lib/stackify-api-ruby.rb

@@ -0,0 +1,166 @@
+require 'stackify/version'
+require 'stackify/utils/methods'
+require 'active_support/core_ext' unless defined? Rails
+
+module Stackify
+
+  INTERNAL_LOG_PREFIX = '[Stackify]'.freeze
+  STATUSES = { working: 'working', terminating: 'terminating', terminated: 'terminated'}
+  MODES = { logging: :logging, metrics: :metrics, both: :both }
+
+  autoload :Backtrace,            'stackify/utils/backtrace'
+  autoload :MsgObject,            'stackify/utils/msg_object'
+  autoload :Configuration,        'stackify/utils/configuration'
+  autoload :HttpClient,           'stackify/http_client'
+  autoload :Authorizable,         'stackify/authorization/authorizable'
+  autoload :EnvDetails,           'stackify/env_details'
+  autoload :Scheduler,            'stackify/scheduler'
+  autoload :ScheduleTask,         'stackify/schedule_task'
+  autoload :Worker,               'stackify/workers/worker'
+  autoload :AuthWorker,           'stackify/workers/auth_worker'
+  autoload :LogsSenderWorker,     'stackify/workers/logs_sender_worker'
+  autoload :AddMsgWorker,         'stackify/workers/add_msg_worker'
+  autoload :MsgsQueue,            'stackify/msgs_queue'
+  autoload :LoggerClient,         'stackify/logger_client'
+  autoload :LogsSender,           'stackify/logs_sender'
+  autoload :LoggerProxy,          'stackify/logger_proxy'
+  autoload :StackifiedError,      'stackify/error'
+  autoload :ErrorsGovernor,       'stackify/errors_governor'
+  autoload :Metrics,              'stackify/metrics/metrics'
+
+  include Authorizable
+
+  class << self
+
+    attr_writer :config
+
+    def configuration
+      @config ||= Stackify::Configuration.new
+    end
+
+    def setup
+      yield(configuration) if block_given?
+      if configuration.is_valid?
+        @status = STATUSES[:working]
+        @workers = []
+      else
+        msg = "Stackify's configuration is not valid!"
+        configuration.errors.each do |error_msg|
+          msg += "\n"+error_msg
+        end
+        raise msg
+      end
+
+    end
+
+    def msgs_queue
+      @msgs_queue ||= Stackify::MsgsQueue.new
+    end
+
+    def logger_client
+      @logger_client ||= Stackify::LoggerClient.new
+    end
+
+    def logs_sender
+      @logs_sender ||= Stackify::LogsSender.new
+    end
+
+    def logger
+      self.configuration.logger
+    end
+
+    def shutdown_all caller_obj=nil
+      @workers.each do |worker|
+        worker.shutdown! unless worker.equal? caller_obj
+      end
+    end
+
+    def alive_adding_msg_workers
+      @workers.select{ |w| w.alive? && w.type == :add_msg }
+    end
+
+    def delete_worker worker
+      @workers.delete worker
+    end
+
+    def add_dependant_worker worker
+      @workers << worker
+    end
+
+    def status
+      @status
+    end
+
+    def log_internal_error msg
+      Stackify.logger.error (::Stackify::INTERNAL_LOG_PREFIX){ msg }
+    end
+
+    def internal_log level, msg
+      Stackify.logger.send(level.downcase.to_sym, Stackify::INTERNAL_LOG_PREFIX){ msg }
+    end
+
+    def run async = true
+      if Stackify.is_valid?
+        at_exit { make_remained_job }
+        t1 = Thread.new { Stackify.authorize }
+        case Stackify.configuration.mode
+        when MODES[:both]
+          t2 = start_logging
+          t3 = start_metrics
+        when MODES[:logging]
+          t2 = start_logging
+        when MODES[:metrics]
+          t3 = start_metrics
+        end
+        unless async
+          t1.join
+          t2.join if t2
+        end
+      end
+    end
+
+    def start_logging
+      Thread.new { Stackify.logs_sender.start}
+    end
+
+    def start_metrics
+      Thread.new { Stackify::Metrics.metrics_client.start }
+    end
+
+    def workers
+      @workers
+    end
+
+    def make_remained_job
+      @status = STATUSES[:terminating]
+      Stackify.msgs_queue.push_remained_msgs
+    end
+
+    def is_valid?
+      configuration.is_valid?
+    end
+
+    def terminating?
+      @status == STATUSES[:terminating]
+    end
+
+    def terminated?
+      @status == STATUSES[:terminated]
+    end
+
+    def working?
+      @status == STATUSES[:working]
+    end
+
+    def status= status
+      if STATUSES.has_value? status
+        @status = status
+      else
+        raise "method 'status=' should get one of arguments #{STATUSES.values}, not a #{status}"
+      end
+    end
+  end
+
+end
+
+require 'stackify/engine' if defined? Rails