netuitive_ruby_api 1.0.1 → 1.1.0

data/config/agent.yml

@@ -1,7 +1,19 @@
 #all are configurable using environment variables
-logLocation: #absolute path of log file. leave blank for default location in the gem directory. environment variable: NETUITIVE_RUBY_LOG_LOCATION
-logAge: daily #Number of old log files to keep, or frequency of rotation (daily, weekly or monthly). environment variable: NETUITIVE_RUBY_LOG_AGE
-logSize: #Maximum logfile size in bytes (only applies when shift_age is a number). environment variable: NETUITIVE_RUBY_LOG_SIZE
-debugLevel: info #options (in ascending order of debugness) are: error, info, debug. environment variable: NETUITIVE_RUBY_DEBUG_LEVEL
-netuitivedAddr: localhost #environment variable: NETUITIVE_RUBY_NETUITIVED_ADDR
-netuitivedPort: 8875 #environment variable: NETUITIVE_RUBY_NETUITIVED_PORT
+#log properties
+logLocation: #NETUITIVE_RUBY_LOG_LOCATION absolute path of log file. leave blank for default location in the gem directory.
+logAge: daily #NETUITIVE_RUBY_LOG_AGE Number of old log files to keep, or frequency of rotation (daily, weekly or monthly).
+logSize: #NETUITIVE_RUBY_LOG_SIZE Maximum logfile size in bytes (only applies when shift_age is a number).
+debugLevel: error #NETUITIVE_RUBY_DEBUG_LEVEL options (in ascending order of debugness) are: error, info, debug.
+
+#netuitived connection properties
+netuitivedAddr: localhost #NETUITIVE_RUBY_NETUITIVED_ADDR
+netuitivedPort: 8875 #NETUITIVE_RUBY_NETUITIVED_PORT
+
+#cache properties
+#the point of the cache is to be as *small* as possible while still avoiding excessive delivery thread growth.
+sampleCacheEnabled: true #NETUITIVE_RUBY_SAMPLE_CACHE_ENABLED
+sampleCacheSize: 50 #NETUITIVE_RUBY_SAMPLE_CACHE_SIZE maximum number of samples to be cached before being sent to netuitived
+sampleCacheInterval: 10 #NETUITIVE_RUBY_SAMPLE_CACHE_INTERVAL interval (in seconds) to send cached samples to netuitived
+eventCacheEnabled: false #NETUITIVE_RUBY_EVENT_CACHE_ENABLED
+eventCacheSize: 50 #NETUITIVE_RUBY_SAMPLE_CACHE_SIZE maximum number of events to be cached before being sent to netuitived
+eventCacheInterval: 10 #NETUITIVE_RUBY_SAMPLE_CACHE_INTERVAL interval (in seconds) to send cached events to netuitived

data/lib/netuitive_ruby_api.rb

@@ -3,39 +3,81 @@ require 'logger'
 require 'drb/drb'
 require 'netuitive_ruby_api/config_manager'
 require 'netuitive_ruby_api/netuitive_logger'
+require 'netuitive_ruby_api/error_logger'
+require 'netuitive_ruby_api/data_cache'
+require 'netuitive_ruby_api/data_manager'
+require 'netuitive_ruby_api/event_schedule'
+require 'netuitive_ruby_api/sample_schedule'
 
 class NetuitiveRubyAPI
   class << self
-    def setup(server)
-      @@netuitivedServer = server
+    attr_accessor :data_manager
+    attr_accessor :netuitivedServer
+    attr_reader :pid
+    def setup
+      @pid = Process.pid
+      NetuitiveRubyApi::ConfigManager.load_config
+      NetuitiveRubyApi::NetuitiveLogger.setup
+      NetuitiveRubyApi::ConfigManager.read_config
+      NetuitiveRubyApi::ErrorLogger.guard('error during api setup') do
+        server_uri = "druby://#{NetuitiveRubyApi::ConfigManager.netuitivedAddr}:#{NetuitiveRubyApi::ConfigManager.netuitivedPort}".freeze
+        DRb.start_service
+        drb_server = DRbObject.new_with_uri(server_uri)
+        data_manager = NetuitiveRubyApi::DataManager.new
+        data_manager.data_cache = NetuitiveRubyApi::DataCache.new
+        data_manager.sample_cache_enabled = NetuitiveRubyApi::ConfigManager.sample_cache_enabled
+        data_manager.sample_cache_size = NetuitiveRubyApi::ConfigManager.sample_cache_size
+        data_manager.sample_cache_interval = NetuitiveRubyApi::ConfigManager.sample_cache_interval
+        data_manager.event_cache_enabled = NetuitiveRubyApi::ConfigManager.event_cache_enabled
+        data_manager.event_cache_size = NetuitiveRubyApi::ConfigManager.event_cache_size
+        data_manager.event_cache_interval = NetuitiveRubyApi::ConfigManager.event_cache_interval
+        data_manager.netuitived_server = drb_server
+        @netuitivedServer = drb_server
+        @data_manager = data_manager
+        NetuitiveRubyApi::SampleSchedule.stop
+        NetuitiveRubyApi::EventSchedule.stop
+        NetuitiveRubyApi::SampleSchedule.start(NetuitiveRubyApi::ConfigManager.sample_cache_interval) if NetuitiveRubyApi::ConfigManager.sample_cache_enabled
+        NetuitiveRubyApi::EventSchedule.start(NetuitiveRubyApi::ConfigManager.event_cache_interval) if NetuitiveRubyApi::ConfigManager.event_cache_enabled
+        NetuitiveRubyApi::NetuitiveLogger.log.info 'netuitive_ruby_api finished setup'
+      end
+    end
+
+    def flush_samples
+      @data_manager.flush_samples
+    end
+
+    def check_restart
+      NetuitiveRubyApi::NetuitiveLogger.log.debug "stored pid: #{@pid}, process pid: #{Process.pid}"
+      return if @pid == Process.pid
+      Thread.new { NetuitiveRubyAPI.setup }
     end
 
-    def netuitivedServer
-      @@netuitivedServer
+    def flush_events
+      @data_manager.flush_events
     end
 
     def send_metrics
-      server_interaction { netuitivedServer.sendMetrics }
+      netuitivedServer.sendMetrics
     end
 
     def add_sample(metric_id, val)
-      server_interaction { netuitivedServer.addSample(metric_id, val) }
+      @data_manager.add_sample(metric_id, val)
     end
 
     def add_counter_sample(metric_id, val)
-      server_interaction { netuitivedServer.addCounterSample(metric_id, val) }
+      @data_manager.add_counter_sample(metric_id, val)
     end
 
     def aggregate_metric(metric_id, val)
-      server_interaction { netuitivedServer.aggregateMetric(metric_id, val) }
+      @data_manager.aggregate_metric(metric_id, val)
     end
 
     def aggregate_counter_metric(metric_id, val)
-      server_interaction { netuitivedServer.aggregateCounterMetric(metric_id, val) }
+      @data_manager.aggregate_counter_metric(metric_id, val)
     end
 
     def clear_metrics
-      server_interaction { netuitivedServer.clearMetrics }
+      netuitivedServer.clearMetrics
     end
 
     def interval
@@ -43,36 +85,17 @@ class NetuitiveRubyAPI
     end
 
     def event(message, timestamp = Time.new, title = 'Ruby Event', level = 'Info', source = 'Ruby Agent', type = 'INFO', tags = nil)
-      server_interaction { netuitivedServer.event(message, timestamp, title, level, source, type, tags) }
+      @data_manager.event(message, timestamp, title, level, source, type, tags)
     end
 
     def exception_event(exception, klass = nil, tags = nil)
-      server_interaction do
-        hash = { message: exception.message }
-        hash[:backtrace] = exception.backtrace.join("\n\t") if (defined? exception.backtrace) && !exception.backtrace.nil?
-        netuitivedServer.exceptionEvent(hash, klass, tags)
-      end
+      @data_manager.exception_event(exception, klass, tags)
     end
 
     def stop_server
-      server_interaction { netuitivedServer.stopServer }
-    end
-
-    def server_interaction
-      Thread.new do
-        begin
-          yield
-        rescue => e
-          NetuitiveRubyApi::NetuitiveLogger.log.error "unable to connect to netuitived: message:#{e.message} backtrace:#{e.backtrace}"
-        end
-      end
+      netuitivedServer.stopServer
     end
   end
 end
 
-NetuitiveRubyApi::ConfigManager.load_config
-NetuitiveRubyApi::NetuitiveLogger.setup
-NetuitiveRubyApi::ConfigManager.read_config
-SERVER_URI = "druby://#{NetuitiveRubyApi::ConfigManager.netuitivedAddr}:#{NetuitiveRubyApi::ConfigManager.netuitivedPort}".freeze
-DRb.start_service
-NetuitiveRubyAPI.setup(DRbObject.new_with_uri(SERVER_URI))
+NetuitiveRubyAPI.setup

data/lib/netuitive_ruby_api/config_manager.rb

@@ -2,10 +2,14 @@ module NetuitiveRubyApi
   class ConfigManager
     class << self
       attr_reader :netuitivedAddr
-
       attr_reader :netuitivedPort
-
       attr_reader :data
+      attr_reader :sample_cache_enabled
+      attr_reader :sample_cache_size
+      attr_reader :sample_cache_interval
+      attr_reader :event_cache_enabled
+      attr_reader :event_cache_size
+      attr_reader :event_cache_interval
 
       def property(name, var, default = nil)
         prop = ENV[var]
@@ -26,12 +30,11 @@ module NetuitiveRubyApi
       end
 
       def float_property(name, var)
-        prop = ENV[var].nil? ? nil : ENV[var]
-        if prop.nil? || (prop == '')
-          data[name].to_f
-        else
-          prop.to_f
-        end
+        property(name, var).to_f
+      end
+
+      def int_property(name, var)
+        property(name, var).to_i
       end
 
       def string_list_property(name, var)
@@ -52,6 +55,12 @@ module NetuitiveRubyApi
       end
 
       def read_config
+        @sample_cache_enabled = boolean_property('sampleCacheEnabled', 'NETUITIVE_RUBY_SAMPLE_CACHE_ENABLED')
+        @sample_cache_size = int_property('sampleCacheSize', 'NETUITIVE_RUBY_SAMPLE_CACHE_SIZE')
+        @sample_cache_interval = int_property('sampleCacheInterval', 'NETUITIVE_RUBY_SAMPLE_CACHE_INTERVAL')
+        @event_cache_enabled = boolean_property('eventCacheEnabled', 'NETUITIVE_RUBY_EVENT_CACHE_ENABLED')
+        @event_cache_size = int_property('eventCacheSize', 'NETUITIVE_RUBY_SAMPLE_CACHE_SIZE')
+        @event_cache_interval = int_property('eventCacheInterval', 'NETUITIVE_RUBY_SAMPLE_CACHE_INTERVAL')
         @netuitivedAddr = property('netuitivedAddr', 'NETUITIVE_RUBY_NETUITIVED_ADDR')
         @netuitivedPort = property('netuitivedPort', 'NETUITIVE_RUBY_NETUITIVED_PORT')
         debugLevelString = property('debugLevel', 'NETUITIVE_RUBY_DEBUG_LEVEL')
@@ -64,12 +73,18 @@ module NetuitiveRubyApi
                                                       else
                                                         Logger::ERROR
                                                       end
-        NetuitiveRubyApi::NetuitiveLogger.log.info "port: #{@netuitivedPort}"
-        NetuitiveRubyApi::NetuitiveLogger.log.info "addr: #{@netuitivedAddr}"
+        NetuitiveRubyApi::NetuitiveLogger.log.info "netuitived port: #{@netuitivedPort}"
+        NetuitiveRubyApi::NetuitiveLogger.log.info "netuitived addr: #{@netuitivedAddr}"
         NetuitiveRubyApi::NetuitiveLogger.log.debug "read config file. Results:
           netuitivedAddr: #{@netuitivedAddr}
           netuitivedPort: #{@netuitivedPort}
-          debugLevel: #{debugLevelString}"
+          debugLevel: #{debugLevelString}
+          sample_cache_enabled: #{@sample_cache_enabled}
+          sample_cache_size: #{@sample_cache_size}
+          sample_cache_interval: #{@sample_cache_interval}
+          event_cache_enabled: #{@event_cache_enabled}
+          event_cache_size: #{@event_cache_size}
+          event_cache_interval: #{@event_cache_interval}"
       end
     end
   end

data/lib/netuitive_ruby_api/data_cache.rb

@@ -0,0 +1,104 @@
+module NetuitiveRubyApi
+  class DataCache
+    def initialize
+      @sample_count_mutex = Mutex.new
+      @event_count_mutex = Mutex.new
+      reset_samples
+      reset_events
+    end
+
+    def sample_added
+      @sample_count += 1
+    end
+
+    def event_added
+      @event_count += 1
+    end
+
+    def add_sample(value)
+      @sample_count_mutex.synchronize do
+        @samples.push(value)
+        sample_added
+      end
+    end
+
+    def add_counter_sample(value)
+      @sample_count_mutex.synchronize do
+        @counter_samples.push(value)
+        sample_added
+      end
+    end
+
+    def add_aggregate_metric(value)
+      @sample_count_mutex.synchronize do
+        @aggregate_metrics.push(value)
+        sample_added
+      end
+    end
+
+    def add_aggregate_counter_metric(value)
+      @sample_count_mutex.synchronize do
+        @aggregate_counter_metrics.push(value)
+        sample_added
+      end
+    end
+
+    def add_event(value)
+      @event_count_mutex.synchronize do
+        @events.push(value)
+        event_added
+      end
+    end
+
+    def add_exception_event(value)
+      @event_count_mutex.synchronize do
+        @exception_events.push(value)
+        event_added
+      end
+    end
+
+    def clear_sample_cache
+      NetuitiveRubyApi::ErrorLogger.guard('error during clear_sample_cache') do
+        @sample_count_mutex.synchronize do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug 'clearing sample cache'
+          ret = {
+            samples: @samples.dup,
+            counter_samples: @counter_samples.dup,
+            aggregate_metrics: @aggregate_metrics.dup,
+            aggregate_counter_metrics: @aggregate_counter_metrics.dup
+          }
+          reset_samples
+          ret
+        end
+      end
+    end
+
+    def clear_event_cache
+      NetuitiveRubyApi::ErrorLogger.guard('error during clear_event_cache') do
+        @event_count_mutex.synchronize do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug 'clearing event cache'
+          ret = {
+            events: @events.dup,
+            exception_events: @exception_events.dup
+          }
+          reset_events
+          ret
+        end
+      end
+    end
+
+    def reset_samples
+      @samples = []
+      @counter_samples = []
+      @aggregate_metrics = []
+      @aggregate_counter_metrics = []
+      @sample_count = 0
+    end
+
+    def reset_events
+      @events = []
+      @exception_events = []
+      @event_count = 0
+    end
+  end
+end

data/lib/netuitive_ruby_api/data_manager.rb

@@ -0,0 +1,142 @@
+module NetuitiveRubyApi
+  class DataManager
+    attr_accessor :data_cache
+    attr_accessor :sample_cache_enabled
+    attr_accessor :sample_cache_size
+    attr_accessor :sample_cache_interval
+    attr_accessor :event_cache_enabled
+    attr_accessor :event_cache_size
+    attr_accessor :event_cache_interval
+    attr_accessor :netuitived_server
+
+    def add_sample(metric_id, val)
+      if @sample_cache_enabled
+        NetuitiveRubyApi::NetuitiveLogger.log.debug "adding sample to cache: #{metric_id}"
+        sample_cache_addition { data_cache.add_sample(metric_id: metric_id, val: val) }
+      else
+        server_interaction { netuitived_server.addSample(metric_id, val) }
+      end
+    end
+
+    def add_counter_sample(metric_id, val)
+      if @sample_cache_enabled
+        NetuitiveRubyApi::NetuitiveLogger.log.debug "adding sample to cache: #{metric_id}"
+        sample_cache_addition { data_cache.add_counter_sample(metric_id: metric_id, val: val) }
+      else
+        server_interaction { netuitived_server.addCounterSample(metric_id, val) }
+      end
+    end
+
+    def aggregate_metric(metric_id, val)
+      if @sample_cache_enabled
+        NetuitiveRubyApi::NetuitiveLogger.log.debug "adding sample to cache: #{metric_id}"
+        sample_cache_addition { data_cache.add_aggregate_metric(metric_id: metric_id, val: val) }
+      else
+        server_interaction { netuitived_server.aggregateMetric(metric_id, val) }
+      end
+    end
+
+    def aggregate_counter_metric(metric_id, val)
+      if @sample_cache_enabled
+        NetuitiveRubyApi::NetuitiveLogger.log.debug "adding sample to cache: #{metric_id}"
+        sample_cache_addition { data_cache.add_aggregate_counter_metric(metric_id: metric_id, val: val) }
+      else
+        server_interaction { netuitived_server.aggregateCounterMetric(metric_id, val) }
+      end
+    end
+
+    def event(message, timestamp, title, level, source, type, tags)
+      if @event_cache_enabled
+        NetuitiveRubyApi::NetuitiveLogger.log.debug "adding event to cache: #{message}"
+        event_cache_addition do
+          data_cache.add_event(message: message,
+                               timestamp: timestamp,
+                               title: title,
+                               level: level,
+                               source: source,
+                               type: type,
+                               tags: tags)
+        end
+      else
+        server_interaction { netuitived_server.event(message, timestamp, title, level, source, type, tags) }
+      end
+    end
+
+    def exception_event(exception, klass, tags)
+      NetuitiveRubyApi::ErrorLogger.guard('error during exception_event') do
+        hash = { message: exception.message }
+        hash[:backtrace] = exception.backtrace.join("\n\t") if (defined? exception.backtrace) && !exception.backtrace.nil?
+        if @event_cache_enabled
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "adding exception event to cache: #{hash[:message]}"
+          event_cache_addition do
+            data_cache.add_exception_event(exception: hash,
+                                           klass: klass,
+                                           tags: tags)
+          end
+        else
+          server_interaction { netuitived_server.exceptionEvent(hash, klass, tags) }
+        end
+      end
+    end
+
+    def flush_samples
+      NetuitiveRubyApi::ErrorLogger.guard('error during flush_samples') do
+        sample = data_cache.clear_sample_cache
+        num = sample[:samples].size + sample[:counter_samples].size + sample[:aggregate_metrics].size + sample[:aggregate_counter_metrics].size
+        NetuitiveRubyApi::NetuitiveLogger.log.info "sending #{num} samples" if num > 0
+        threads = []
+        threads << server_interaction do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "sending samples: #{sample[:samples]} "
+          netuitived_server.add_samples sample[:samples]
+        end unless sample[:samples].empty?
+        threads << server_interaction do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "sending counter_samples: #{sample[:counter_samples]} "
+          netuitived_server.add_counter_samples sample[:counter_samples]
+        end unless sample[:counter_samples].empty?
+        threads << server_interaction do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "sending aggregate_metrics: #{sample[:aggregate_metrics]} "
+          netuitived_server.add_aggregate_metrics sample[:aggregate_metrics]
+        end unless sample[:aggregate_metrics].empty?
+        threads << server_interaction do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "sending aggregate_counter_metrics: #{sample[:aggregate_counter_metrics]} "
+          netuitived_server.add_aggregate_counter_metrics sample[:aggregate_counter_metrics]
+        end unless sample[:aggregate_counter_metrics].empty?
+        threads
+      end
+    end
+
+    def flush_events
+      NetuitiveRubyApi::ErrorLogger.guard('error during flush_events') do
+        event_cache = data_cache.clear_event_cache
+        num = event_cache[:events].size + event_cache[:exception_events].size
+        NetuitiveRubyApi::NetuitiveLogger.log.info "sending #{num} events" if num > 0
+        threads = []
+        threads << server_interaction do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "sending events: #{event_cache[:events]} "
+          netuitived_server.add_events(event_cache[:events])
+        end unless event_cache[:events].empty?
+        threads << server_interaction do
+          NetuitiveRubyApi::NetuitiveLogger.log.debug "sending exception_events: #{event_cache[:exception_events]} "
+          netuitived_server.add_exception_events(event_cache[:exception_events])
+        end unless event_cache[:exception_events].empty?
+        threads
+      end
+    end
+
+    def sample_cache_addition
+      NetuitiveRubyAPI.check_restart
+      flush_samples if yield >= @sample_cache_size
+    end
+
+    def event_cache_addition
+      NetuitiveRubyAPI.check_restart
+      flush_events if yield >= @event_cache_size
+    end
+
+    def server_interaction
+      Thread.new do
+        NetuitiveRubyApi::ErrorLogger.guard('error during server interaction') { yield }
+      end
+    end
+  end
+end

data/lib/netuitive_ruby_api/error_logger.rb

@@ -0,0 +1,21 @@
+# Important! ruby rescue logic is expensive.
+# This class is *intended* to be used as a catch all, because we don't want any errors to not be logged
+# or worse to bubble up to the host application.
+# That *doesn't* mean we should be throwing exceptions rather than guarding against them
+# From the benchmarks I've read it seems like rescues are free if no exception is thrown
+module NetuitiveRubyApi
+  class ErrorLogger
+    class << self
+      def guard(message)
+        yield
+      rescue => e
+        NetuitiveRubyApi::NetuitiveLogger.log.error format_exception(e, message)
+      end
+
+      def format_exception(exception, *message)
+        message = '' unless defined? message || message.nil?
+        "#{message} \n\tException message: #{exception.message}\n\t Backtrace: #{exception.backtrace.join("\n\t")}"
+      end
+    end
+  end
+end

data/lib/netuitive_ruby_api/event_schedule.rb

@@ -0,0 +1,22 @@
+module NetuitiveRubyApi
+  class EventSchedule
+    def self.start(interval)
+      @@thread = Thread.new do
+        loop do
+          sleep(interval)
+          Thread.new do
+            NetuitiveRubyApi::NetuitiveLogger.log.debug 'started event job'
+            NetuitiveRubyApi::ErrorLogger.guard('error during event job') do
+              NetuitiveRubyAPI.flush_events
+            end
+            NetuitiveRubyApi::NetuitiveLogger.log.debug 'finished event job'
+          end
+        end
+      end
+    end
+
+    def self.stop
+      @@thread.kill if defined? @@thread
+    end
+  end
+end

data/lib/netuitive_ruby_api/netuitive_logger.rb

@@ -14,7 +14,7 @@ module NetuitiveRubyApi
 
   class NetuitiveLogger
     class << self
-      attr_reader :log
+      attr_accessor :log
       def setup
         file = NetuitiveRubyApi::ConfigManager.property('logLocation', 'NETUITIVE_RUBY_LOG_LOCATION', "#{File.expand_path('../../..', __FILE__)}/log/netuitive.log")
         age = NetuitiveRubyApi::ConfigManager.property('logAge', 'NETUITIVE_RUBY_LOG_AGE', 'daily')

data/lib/netuitive_ruby_api/sample_schedule.rb

@@ -0,0 +1,22 @@
+module NetuitiveRubyApi
+  class SampleSchedule
+    def self.start(interval)
+      @@thread = Thread.new do
+        loop do
+          sleep(interval)
+          Thread.new do
+            NetuitiveRubyApi::NetuitiveLogger.log.debug 'started sample job'
+            NetuitiveRubyApi::ErrorLogger.guard('error during sample job') do
+              NetuitiveRubyAPI.flush_samples
+            end
+            NetuitiveRubyApi::NetuitiveLogger.log.debug 'finished sample job'
+          end
+        end
+      end
+    end
+
+    def self.stop
+      @@thread.kill if defined? @@thread
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: netuitive_ruby_api
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,37 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-17 00:00:00.000000000 Z
-dependencies: []
+date: 2016-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: netuitived
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 description: Allows for easy submittion of metrics to Netuitive
 email: jking@netuitive.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/netuitive_ruby_api/sample_schedule.rb
 - lib/netuitive_ruby_api/netuitive_logger.rb
+- lib/netuitive_ruby_api/data_manager.rb
+- lib/netuitive_ruby_api/data_cache.rb
 - lib/netuitive_ruby_api/config_manager.rb
+- lib/netuitive_ruby_api/event_schedule.rb
+- lib/netuitive_ruby_api/error_logger.rb
 - lib/netuitive_ruby_api.rb
 - config/agent.yml
 - ./LICENSE