stackify-api-ruby 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91576c0ba41af7311a30a4fad37f1d79d6094183
-  data.tar.gz: cf5c824bb9ab986fcb497bc9ed1ed754a4f3093d
+  metadata.gz: df701108ebb0ac52a8a5195f2922474c492cea5d
+  data.tar.gz: 9e007bbdb78a24f3ec46a7271fa549b3d211b747
 SHA512:
-  metadata.gz: 2b76008856dec9a3222956299826567e8c5f410c814034620bd4288f8e90104803b166163b83fd1aba30c7ba24596a558691b30017d5e61b16f6b320aa198038
-  data.tar.gz: 4f5ec661d4004383633a6fe4807435cc447e697a81e54bc29603ac3566ba318effa84eb8a38e0b4db449675a945bbdb366dd28070bb0bf2e91be9f83371c1011
+  metadata.gz: 658c332b7564e08970931134aa26b971704acc9682609ef92a93c20d25e252ab5f60cbe775383cee144c8219d0b6b5e96cc4a67b57be1153250c8d5088bea271
+  data.tar.gz: 595d74f79383ad2aa17942f2a747d3d15e8f821d324abb0d021719f1114b3e910eb8321545e3b8d40064661f9d6990a2e5773598ac2c7c55022a4c3882140b60

data/README.md

@@ -1,12 +1,20 @@
-# Stackify
+# stackify-api-ruby
 
-Stackify Logs and Metrics API for Ruby
+Stackify Logs and Metrics API for Ruby.
 
+Errors and Logs Overview:
 
-Rails Installation
-------------------
+http://docs.stackify.com/m/7787/l/189767
 
-### Rails 3.x/4.x
+Sign Up for a Trial:
+
+http://www.stackify.com/sign-up/
+
+## Installation and Configuration
+
+Requirements: Ruby 1.9/2.0/2.1, Rails 3.x/4.x (optional)
+
+### Rails
 
 Add the stackify gem to your Gemfile. In Gemfile:
 
@@ -16,7 +24,7 @@ Run the bundle command to install it:
 
     $ bundle
 
-Or install it manually:
+or install it manually:
 
     $ gem install stackify-api-ruby
 
@@ -26,15 +34,7 @@ After you install stackify-api-ruby you need to run the generator:
 
 The generator creates a file '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 with start of Rails. Every error, which occurs within your application, will be caught 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
+### Non-Rails
 
 For using stackify-api-ruby gem within any Ruby application add to top of your main file:
 
@@ -46,40 +46,45 @@ After that you need to make base configuration:
       config.api_key = "your_api_key"
       config.env = :development
       config.app_name = "Your 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).
+## Optional Configuration
 
 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
-
 If you want to use proxy for sending request, you can do it in such way:
 
     config.proxy = { uri: '127.0.0.1:8118', user: 'user_name', password: 'some_password' }
 
-For internal logging stackify-api-ruby uses such logger:
+## Log API Usage
 
-    config.logger = Logger.new(File.join(Rails.root, "log", "stackify.log"))
+### Rails
+
+stackify-api-ruby starts with start of Rails. Every error, which occurs within your application, will be caught and sent to Stackify automatically. The same situation with logs - you just use the Rails logger as usual:
+
+    Rails.logger.info "Some log message"
+
+If you want to redefine <b>logger</b>, you should add
+
+    config.logger = ::Stackify::LoggerProxy.new(ActiveSupport::Logger.new(File.join(Rails.root, 'log', "#{Rails.env}.log")))
+
+to your config/environments/%environment%. <b>Note:</b> in this case Stackify#config.log_level will affect entire system.
+
+### Non-Rails
 
 After logs configuring 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
-------------------
+## Metrics API Usage
 
 There are four different types of metrics:
 
@@ -99,6 +104,8 @@ There are four different types of metrics:
 
         t = Time.now
         Stackify::Metrics.time "MyCategory", "ElapsedTime", t
+        # or
+        Stackify::Metrics.time_duration "MyCategory", "ElapsedTime", 5.seconds
 
 - **Counter and Timer**: Composite of the Counter and Timer metrics for convenience
 
@@ -107,7 +114,7 @@ There are four different types of metrics:
 
 We can configure every metric with settings:
 
-        settings = MetricSettings.new
+        settings = Stackify::Metrics::MetricSettings.new
         settings.autoreport_zero_if_nothing_reported = true
         # or
         settings.autoreport_last_value_if_nothing_reported = true
@@ -115,26 +122,27 @@ We can configure every metric with 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
+## Troubleshooting
 
-    ``` Stackify::Metrics.get_latest "MyCategory", "MyCounter" ```
+If there are problems, you can enable internal logging of the stackify-api-ruby project. Uncomment out the config.logger and config.logger.level lines in the 'config/initializers/stackify.rb' file:
 
-- get_latest_all_metrics - return all values of existed metrics
+```
+config.logger = Logger.new(File.join(Rails.root, "log", "stackify.log"))
+config.logger.level = Logger::DEBUG
+```
 
-    ``` Stackify::Metrics.get_latest_all_metrics```
+## License
 
-## Requirements
-Ruby: 1.9/2.0/2.1
+Copyright 2015 Stackify, LLC.
 
-Rails: 3.x/4.x
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-Contributing
-------------------
+   http://www.apache.org/licenses/LICENSE-2.0
 
-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
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/lib/stackify/authorization/authorizable.rb

@@ -30,11 +30,11 @@ module Stackify::Authorizable
 
     def successfull_authorisation response
       Stackify::EnvDetails.instance.update_auth_info JSON.parse(response.body)
-      Stackify.internal_log :info, 'Authorisation is finished successfully.'
+      Stackify.internal_log :info, 'Authorization is finished successfully.'
     end
 
     def unsuccessfull_authorisation response, caller
-      Stackify.log_internal_error "Authorisation finally failed: #{response_string(response)}"
+      Stackify.log_internal_error "Authorization finally failed: #{response_string(response)}"
       Stackify.shutdown_all caller unless @@authorized
     end
 

data/lib/stackify/authorization/authorization_client.rb

@@ -22,7 +22,7 @@ module Stackify::Authorizable
         end
       }
       Stackify::ScheduleTask.new properties do
-        Stackify.internal_log :debug, 'AthorizationClient: trying to athorize...'
+        Stackify.internal_log :debug, 'AthorizationClient: trying to authorize...'
         send_request BASE_URI, Stackify::EnvDetails.instance.auth_info.to_json
       end
     end

data/lib/stackify/error.rb

@@ -1,5 +1,9 @@
 module Stackify
-
+  class StringException < StandardError
+    def class
+      'StringException'.freeze
+    end
+  end
   class StackifiedError < StandardError
 
     CONTEXT_PROPERTIES =  { 'user' => 'current_user'}

data/lib/stackify/logger_client.rb

@@ -5,11 +5,11 @@ module Stackify
       @@errors_governor = Stackify::ErrorsGovernor.new
     end
 
-    def log level, msg
+    def log level, msg, call_trace
       Stackify::Utils.do_only_if_authorized_and_mode_is_on Stackify::MODES[:logging] do
         if acceptable? level, msg && Stackify.working?
           worker = Stackify::AddMsgWorker.new
-          task = log_message_task level, msg
+          task = log_message_task level, msg, call_trace
           worker.async_perform ScheduleDelay.new, task
         end
       end
@@ -56,9 +56,22 @@ module Stackify
       Stackify.configuration.env.downcase.to_sym == Stackify::EnvDetails.instance.auth_info['ConfiguredEnvironmentName'].downcase.to_sym
     end
 
-    def log_message_task level, msg
+    def log_message_task level, msg, call_trace
       Stackify::ScheduleTask.new ({limit: 1}) do
-        Stackify.msgs_queue << Stackify::MsgObject.new(level, msg, caller[0]).to_h
+        if %w(error fatal).include?(level)
+          ex = if ruby_exception?(msg) && msg.class != Class
+            msg.set_backtrace(call_trace)
+            msg
+          else
+            e = StringException.new(msg)
+            e.set_backtrace(call_trace)
+            e
+          end
+          ex = StackifiedError.new(ex, binding())
+          Stackify.msgs_queue << Stackify::MsgObject.new(level, ex.message, caller[0], ex).to_h
+        else
+          Stackify.msgs_queue << Stackify::MsgObject.new(level, msg, caller[0]).to_h
+        end
       end
     end
 
@@ -67,6 +80,16 @@ module Stackify
         Stackify.msgs_queue << Stackify::MsgObject.new(level, ex.message, caller[0], ex).to_h
       end
     end
+
+    def ruby_exception? klass
+      klass = klass.class == Class ? klass : klass.class
+      klasses = [klass]
+      while klass != Object do
+        klasses << klass.superclass
+        klass = klass.superclass
+      end
+      klasses.include?(Exception)
+    end
   end
 
 end

data/lib/stackify/logger_proxy.rb

@@ -4,12 +4,17 @@ module Stackify
     def initialize logger
       @logger = logger
       @logger.level = Logger.const_get(Stackify.configuration.log_level.to_s.upcase)
-      %w( debug info warn error fatal unknown).each do |level|
+      %w(debug info warn error fatal unknown).each do |level|
+        stackify_logger = if level == 'debug'
+          -> (msg, caller) { Stackify.logger_client.log(level.downcase, msg, caller) unless msg.empty? }
+        else
+          -> (msg, caller) { Stackify.logger_client.log(level.downcase, msg, caller) }
+        end
         LoggerProxy.class_eval do
           define_method level.to_sym do |*args , &block|
-            msg = message(args, block)
-            Stackify.logger_client.log(level.downcase, msg)
-            @logger.send(level.to_sym, args, &block)
+            msg = message(*args, &block)
+            stackify_logger.call(msg, caller)
+            @logger.send(level.to_sym, msg, &block)
           end
         end
       end
@@ -24,10 +29,12 @@ module Stackify
     private
 
     def message *args, &block
-      if block
+      if block_given?
         block.call
       else
-        args.flatten[0]
+        args = args.flatten.compact
+        args = (args.count == 1 ? args[0] : args)
+        args.is_a?(Proc) ? args.call : args
       end
     end
 

data/lib/stackify/metrics/metric_aggregate.rb

@@ -2,7 +2,7 @@ module Stackify::Metrics
   class MetricAggregate
 
     attr_accessor :name, :category, :value, :count, :occurred_utc,
-                  :monitor_id, :metric_type, :name_key
+                  :monitor_id, :metric_type, :name_key, :sent, :is_increment
 
     def initialize metric
       @name = metric.name
@@ -12,6 +12,8 @@ module Stackify::Metrics
       @count = 0
       @occurred_utc = metric.get_rounded_time
       @name_key = metric.calc_name_key
+      @sent = false
+      @is_increment = metric.is_increment
     end
 
     def aggregate_key
@@ -38,7 +40,6 @@ module Stackify::Metrics
 
     def to_h
       {
-        'Count' => @count,
         'MetricType' => @metric_type,
         'MetricID' => @metric_id,
         'Name' => @name,

data/lib/stackify/metrics/metrics.rb

@@ -62,14 +62,19 @@ module Stackify
         Stackify::Metrics.metrics_client.queue_metric m
       end
 
-      def time category, metric_name, start_time
+      def time category, metric_name, start_time, advanced_settings = nil
         time_taken = Time.now.utc - start_time.utc
-        avarage_time category, metric_name, time_taken
+        avarage_time category, metric_name, time_taken, advanced_settings
       end
 
-      def avarage_time category, metric_name, elapsed_time
+      def time_duration category, metric_name, duration_time, advanced_settings = nil
+        avarage_time category, metric_name, duration_time, advanced_settings
+      end
+
+      def avarage_time category, metric_name, elapsed_time, advanced_settings = nil
         m = Metric.new category, metric_name, Stackify::Metrics::METRIC_TYPES[:counter_time]
         m.value = elapsed_time.round #seconds
+        m.settings = advanced_settings
         Stackify::Metrics.metrics_client.queue_metric m
       end
 

data/lib/stackify/metrics/metrics_client.rb

@@ -60,82 +60,41 @@ module Stackify::Metrics
       #read everything up to the start of the current minute
       read_queued_metrics_batch current_time
       handle_zero_reports current_time
-      get_for_recent = @aggregate_metrics.select do |_k, v|
-        v.occurred_utc < current_time && v.occurred_utc > current_time - 5.minutes
-      end
-      set_latest_aggregates get_for_recent
-      selected_aggr_metrics = @aggregate_metrics.select { |_key, aggr| aggr.occurred_utc < current_time }
+
+      selected_aggr_metrics = @aggregate_metrics.select { |_key, aggr| aggr.occurred_utc.to_i < current_time.to_i && !aggr.sent }
       first_50_metrics = Hash[selected_aggr_metrics.to_a.take 50]
       if first_50_metrics.length > 0
         #only getting metrics less than 10 minutes old to drop old data in case we get backed up
         #they are removed from the @aggregated_metrics in the upload function upon success
-        all_success = upload_aggregates(first_50_metrics.select { |_key, aggr| aggr.occurred_utc > current_time - 10.minutes })
+        upload_aggregates(first_50_metrics.select { |_key, aggr| aggr.occurred_utc > current_time - 10.minutes })
       end
       @aggregate_metrics.delete_if { |_key, aggr| aggr.occurred_utc < purge_older_than }
     end
 
-    def read_queued_metrics_batch chosen_time
-      batches = {}
-
+    def read_queued_metrics_batch current_time
       while  @metrics_queue.size > 0 do
+        break if Stackify::Utils.rounded_current_time.to_i != current_time.to_i
         metric = @metrics_queue.pop
         metric.calc_and_set_aggregate_key
-        unless batches.has_key? metric.aggregate_key
-          name_key = metric.calc_name_key
-          if metric.is_increment && @last_aggregates.has_key?(name_key)
-            #if wanting to do increments we need to grab the last value so we know what to increment
-            metric.value = @last_aggregates[name_key].value
-          end
-          batches[metric.aggregate_key] = MetricAggregate.new metric
-          #if it is nil don't do anything
-          #we are doing it where the aggregates are created so we don't do it one very single metric,
-          #just once per batch to optimize performance
-
-          @metric_settings[name_key] = metric.settings if metric.settings != nil
+        metric_for_aggregation = MetricAggregate.new(metric)
+        name_key = metric.calc_name_key
+        if @last_aggregates.has_key?(name_key) &&
+            (metric.is_increment || @last_aggregates[name_key].occurred_utc.to_i == current_time.to_i)
+          metric_for_aggregation.value = @last_aggregates[name_key].value
+          metric_for_aggregation.count = @last_aggregates[name_key].count
         end
-        batches[metric.aggregate_key].count += 1
-        if metric.is_increment
-          #add or subtract
-          batches[metric.aggregate_key].value += metric.value
-        elsif metric.metric_type == Stackify::Metrics::METRIC_TYPES[:metric_last]
-          #should end up the last value
-          batches[metric.aggregate_key].value = metric.value
-        else
-          batches[metric.aggregate_key].value += metric.value
-        end
-        #we don't need anything more this recent so bail
-        break if metric.occurred > chosen_time
-      end
-      batches.each_pair do |_key, aggregated_metric|
-        aggregate aggregated_metric
-      end
-    end
 
-    def aggregate am
-      agg_key = am.aggregate_key
-      if @aggregate_metrics.has_key? agg_key
-        agg = @aggregate_metrics[agg_key]
-      else
-        if @aggregate_metrics.length > 1000
-          str = 'No longer aggregating new metrics because more than 1000 are queued'
-          Stackify.internal_log :warn, str
-          return
-        end
-        Stackify.internal_log :debug, 'Creating aggregate for ' + agg_key
-        @aggregate_metrics[agg_key] = am
-        agg = Stackify::Metrics::Metric.new am.category, am.name, am.metric_type
-        agg = MetricAggregate.new agg
-        agg.occurred_utc = am.occurred_utc
-      end
+        @metric_settings[name_key] = metric.settings if metric.settings != nil
 
-      if am.metric_type == Stackify::Metrics::METRIC_TYPES[:metric_last]
-        agg.count = 1
-        agg.value = am.value
-      else
-        agg.count += am.count
-        agg.value += am.value
+        if metric.metric_type == Stackify::Metrics::METRIC_TYPES[:metric_last] && !metric.is_increment
+          metric_for_aggregation.value = metric.value
+          metric_for_aggregation.count = 1
+        else
+          metric_for_aggregation.value += metric.value
+          metric_for_aggregation.count += 1
+        end
+        @last_aggregates[name_key] = @aggregate_metrics[metric.aggregate_key] = metric_for_aggregation
       end
-      @aggregate_metrics[agg_key]= agg
     end
 
     def submit_metrics_task
@@ -152,20 +111,22 @@ module Stackify::Metrics
             @metric_settings.delete[aggregate.name_key]
             next
           end
-          #agg = MetricAggregate.new aggregate.category, aggregate.name, aggregate.metric_type
-          agg = aggregate
+          agg = aggregate.clone
           agg.occurred_utc = current_time
-          case aggregate.metric_type
-          when Stackify::Metrics::METRIC_TYPES[:metric_last]
-            setting.autoreport_last_value_if_nothing_reported = false #do not allow this
-          when Stackify::Metrics::METRIC_TYPES[:counter]
-            setting.autoreport_last_value_if_nothing_reported = false #do not allow this
+
+          disabled_autoreport_last = [
+              Stackify::Metrics::METRIC_TYPES[:counter],
+              Stackify::Metrics::METRIC_TYPES[:timer]
+          ]
+          if disabled_autoreport_last.include? aggregate.metric_type
+            settings.autoreport_last_value_if_nothing_reported = false #do not allow this
           end
+
           if settings.autoreport_zero_if_nothing_reported
-            agg.count = 1
+            agg.count = 0
             agg.value = 0
           elsif settings.autoreport_last_value_if_nothing_reported
-            agg.count = aggregate.value.to_i
+            agg.count = aggregate.count.to_i
             agg.value = aggregate.value
           else
             next
@@ -173,7 +134,8 @@ module Stackify::Metrics
           agg_key = agg.aggregate_key
           unless @aggregate_metrics.has_key? agg_key
             agg.name_key = aggregate.name_key
-            Stackify.internal_log :debug, 'Creating 0 default value for ' + agg_key
+            agg.sent = false
+            Stackify.internal_log :debug, 'Creating default value for ' + agg_key
             @aggregate_metrics[agg_key] = agg
           end
         end
@@ -192,18 +154,13 @@ module Stackify::Metrics
     end
 
     def upload_aggregates aggr_metrics
-      s = ''
-      aggr_metrics.each_pair do |_k, m|
-        s = s + m.inspect.to_s + "\n --------------------------- \n"
-      end
-      Stackify.internal_log :debug, "Uploading Aggregate Metrics at #{ Time.now }: \n" + s
       all_success = true
       aggr_metrics.each_pair do |_key, metric|
         if @monitor_ids.has_key? metric.name_key
           mon_info = @monitor_ids[metric.name_key]
         else
           req = @metrics_sender.monitor_info metric
-          if req.try(:code) == '200'
+          if req.try(:status) == 200
             mon_info = JSON.parse req.body
             if !mon_info.nil? && !mon_info['MonitorID'].nil? && mon_info['MonitorID'] > 0
               @monitor_ids[metric.name_key] = mon_info
@@ -225,13 +182,12 @@ module Stackify::Metrics
         else
           metric.monitor_id = mon_info['MonitorID']
         end
-
-        #get identified once
-        aggr_metrics_for_upload = aggr_metrics.select { |_key, aggr_metric| !aggr_metric.monitor_id.nil? }
-        response = @metrics_sender.upload_metrics aggr_metrics_for_upload
-        Stackify.internal_log :info, 'Metrics are uploaded successfully' if response.try(:code) == '200'
-        all_success
       end
+
+      #get identified once
+      aggr_metrics_for_upload = aggr_metrics.select { |_key, aggr_metric| !aggr_metric.monitor_id.nil? }
+      @metrics_sender.upload_metrics aggr_metrics_for_upload
+      all_success
     end
   end
 end

data/lib/stackify/metrics/metrics_sender.rb

@@ -7,22 +7,27 @@ module Stackify::Metrics
       if Stackify.authorized?
         send_request GET_METRIC_INFO_URI, GetMetricRequest.new(aggr_metric).to_h.to_json
       else
-        Stackify.log_internal_error "Getting of monitor_info is failed because of authorisation failure"
+        Stackify.log_internal_error "Getting of monitor_info is failed because of authorization failure"
       end
     end
 
     def upload_metrics aggr_metrics
       return true if aggr_metrics.nil? || aggr_metrics.length == 0
+      current_time = Stackify::Utils.rounded_current_time
       if Stackify.authorized?
         records = []
         aggr_metrics.each_pair do |_key, metric|
+          next if metric.sent || metric.occurred_utc.to_i >= current_time.to_i
           records << Stackify::Metrics::MetricForSubmit.new(metric).to_h
-          prms = [metric.category, metric.name, metric.count, metric.value, metric.monitor_id ]
-          Stackify.internal_log :debug, 'Uploading metric: %s: %s count %s, value %s, ID %s' %  prms
+          metric.sent = true
+        end
+        if records.any?
+          Stackify.internal_log :debug, "Uploading Aggregate Metrics at #{ Time.now }: \n" + JSON.pretty_generate(records)
+          response = send_request SUBMIT_METRIS_URI, records.to_json
+          Stackify.internal_log :info, 'Metrics are uploaded successfully' if response.try(:status) == 200
         end
-        send_request SUBMIT_METRIS_URI, records.to_json
       else
-        Stackify.log_internal_error "Uploading of metrics is failed because of authorisation failure"
+        Stackify.log_internal_error "Uploading of metrics is failed because of authorization failure"
       end
     end
   end

data/lib/stackify/utils/configuration.rb

@@ -17,11 +17,8 @@ module Stackify
       @send_interval = 60
       @log_level = :info
       @mode = MODES[:both]
-      @logger = if defined? Rails
-        Logger.new(File.join(Rails.root, 'log', 'stackify.log'))
-      else
-        Logger.new('stackify.log')
-      end
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::UNKNOWN
     end
 
     def is_valid?

data/lib/stackify/utils/msg_object.rb

@@ -10,7 +10,7 @@ module Stackify
         'data' => nil,
         'Ex' => @ex.try(:to_h),
         'Level' => @level.to_s.upcase!,
-        'Tags' => %w(ruby rails),
+        #'Tags' => %w(ruby rails),
         'EpochMs' => Time.now.to_f * 1000,
         'Th' => Thread.current.object_id.to_s,
         'TransID' => Stackify::EnvDetails.instance.request_details.try{ |d| d['uuid'] },

data/lib/stackify/version.rb

@@ -1,3 +1,3 @@
 module Stackify
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
 end

data/lib/stackify-api-ruby.rb

@@ -27,6 +27,7 @@ module Stackify
   autoload :LogsSender,           'stackify/logs_sender'
   autoload :LoggerProxy,          'stackify/logger_proxy'
   autoload :StackifiedError,      'stackify/error'
+  autoload :StringException,      'stackify/error'
   autoload :ErrorsGovernor,       'stackify/errors_governor'
   autoload :Metrics,              'stackify/metrics/metrics'
 

data/stackify-api-ruby.gemspec

@@ -5,7 +5,7 @@ require 'stackify/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'stackify-api-ruby'
-  spec.version       = '1.0.3'
+  spec.version       = Stackify::VERSION
   spec.authors       = ['Stackify']
   spec.email         = ['support@stackify.com']
   spec.summary       = 'Stackify API for Ruby'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackify-api-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Stackify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-10 00:00:00.000000000 Z
+date: 2015-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler