appoptics-api-ruby 2.1.3

data/Rakefile

@@ -0,0 +1,63 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+# Packaging
+Bundler::GemHelper.install_tasks
+
+# Gem signing
+task 'before_build' do
+  signing_key = File.expand_path("~/.gem/appoptics-private_key.pem")
+  if signing_key
+    puts "Key found: signing gem..."
+    ENV['GEM_SIGNING_KEY'] = signing_key
+  else
+    puts "WARN: signing key not found, gem not signed"
+  end
+end
+task :build => :before_build
+
+# Testing
+require 'rspec/core/rake_task'
+
+desc "Run all tests"
+task :spec do
+  Rake::Task['spec:unit'].execute
+  if ENV['TEST_API_USER'] && ENV['TEST_API_KEY']
+    Rake::Task['spec:integration'].execute
+  else
+    puts "TEST_API_USER and TEST_API_KEY not in environment, skipping integration tests..."
+  end
+end
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.rspec_opts = '--color'
+    t.pattern = 'spec/unit/**/*_spec.rb'
+  end
+
+  RSpec::Core::RakeTask.new(:integration) do |t|
+    t.rspec_opts = '--color'
+    t.pattern = 'spec/integration/**/*_spec.rb'
+  end
+end
+
+task default: :spec
+task test: :spec
+
+# Docs
+require 'yard'
+YARD::Rake::YardocTask.new
+
+# IRB
+desc "Open an irb session preloaded with this library"
+task :console do
+  if !`which pry`.empty?
+    sh "pry -r ./lib/appoptics/metrics.rb"
+  else
+    sh "irb -rubygems -r ./lib/appoptics/metrics.rb"
+  end
+end

data/appoptics-api-ruby.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'appoptics/metrics/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'appoptics-api-ruby'
+  s.version     = '2.1.3'
+  s.date        = '2017-10-13'
+  s.summary     = "Ruby bindings for the AppOptics API"
+  s.description = "An easy to use ruby wrapper for the AppOptics API"
+  s.authors     = ["Greg McKeever", "Matt Sanders"]
+  s.email       = 'greg@solarwinds.cloud'
+  s.files       = ["lib/appoptics/metrics.rb"]
+  s.homepage    =
+    'https://github.com/AppOptics/appoptics-api-ruby'
+  s.license       = 'BSD 3-clause'
+  s.require_paths = %w[lib]
+
+## runtime dependencies
+  s.add_dependency 'faraday'
+  s.add_dependency 'aggregate', '~> 0.2.2'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.cert_chain = ["certs/appoptics-public.pem"]
+  if ENV['GEM_SIGNING_KEY']
+    s.signing_key = ENV['GEM_SIGNING_KEY']
+  end
+end

data/benchmarks/array_vs_set.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'tach'
+require 'set'
+
+# Compare speed of simple addition and iteration operations.
+#
+Tach.meter(1000) do
+  
+  tach('array') do
+    a = []
+    (1..1000).each do |i|
+      a << i
+    end
+    a.each do |i|
+      "this is a string with #{i}"
+    end
+  end
+  
+  tach('set') do
+    s = Set.new
+    (1...1000).each do |i|
+      s << i
+    end
+    s.each do |i|
+      "this is a string with #{i}"
+    end
+  end
+  
+end

data/certs/librato-public.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDLjCCAhagAwIBAgIBADANBgkqhkiG9w0BAQUFADA9MQ0wCwYDVQQDDARydWJ5
+MRcwFQYKCZImiZPyLGQBGRYHbGlicmF0bzETMBEGCgmSJomT8ixkARkWA2NvbTAe
+Fw0xNzAxMTExODI3MDdaFw0xODAxMTExODI3MDdaMD0xDTALBgNVBAMMBHJ1Ynkx
+FzAVBgoJkiaJk/IsZAEZFgdsaWJyYXRvMRMwEQYKCZImiZPyLGQBGRYDY29tMIIB
+IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA58LirwsWnKL1uuClQ0uwA1XL
+GpxDuFzSosipiPkzZY3hiHazC8SHDREZQXlm7ITX/o+dueNoB7dt0BR3RPVipH7V
+7cvbCUaZNjEXR5Lal6PsmUsbMTrddkvj3e7flmJv+kMj+teeJ7MDeJTU5wXXV9pD
+ThiCDILJMF5CdP8Jru4rSBOP6RmmzYU+0cN5+5pt9xqrycA+Poo2ZuoUMCMsSBvl
+PimM3PPvoWTuE41GTn/bLoOVoXQmdwZIbwUSVH8rCDjZSlttOst+xrBw4KG0dYUp
+2UvEe8iCyqEMQ8fEZ7EXuP2WMVICutFbz8Pt4hIMq+OTnDX+mIfma7GvPaKAFwID
+AQABozkwNzAJBgNVHRMEAjAAMB0GA1UdDgQWBBQBSxu9Jj4VTrXTpLujPwk9Kzwp
+2jALBgNVHQ8EBAMCBLAwDQYJKoZIhvcNAQEFBQADggEBACvNsw1pGv72xp3LiDlZ
+0tphNP/85RcYyJMklslG3tIYblyo71xHW1UbK5ArUK6k0BN43MuDn3pqLJQttVmi
+bUdA3yYi13GeSrrAMlr4nH8Yt/Bn/XpZGliouJUBwh1BjG6dSj1iuR4/9pt9/LtO
+QTdIc+07qGspypT0Uh/w/BodEcGuAaZZFlkU9vottTe6wWNnM6hfRExiSIsr+oVe
+s8s83ObshjuSzjOqS56IBtNlPEL+D6ghjZZLP3lS6l9p70Pcpcl+IcE4veqZmmKC
+sGepgRclC6UbZh+yQ3alXVghM2qsonAwI/rTNmFJN9kQn6nP9+f1Uf/qZFNcjn4L
+9bg=
+-----END CERTIFICATE-----

data/examples/simple.rb

@@ -0,0 +1,24 @@
+require 'appoptics-api-ruby'
+
+Appoptics::Metrics.authenticate 'my email', 'my api key'
+
+# send a measurement of 12 for 'foo'
+Appoptics::Metrics.submit cpu: 54
+
+# submit multiple metrics at once
+Appoptics::Metrics.submit cpu: 63, memory: 213
+
+# submit a metric with a custom source
+Appoptics::Metrics.submit cpu: {source: 'myapp', value: 75}
+
+# if you are sending many metrics it is much more performant
+# to submit them in sets rather than individually:
+
+queue = Appoptics::Metrics::Queue.new
+
+queue.add 'disk.free' => 1223121
+queue.add memory: 2321
+queue.add cpu: {source: 'myapp', value: 52}
+#...
+
+queue.submit

data/examples/submit_every.rb

@@ -0,0 +1,27 @@
+# send a set of metrics every 60 seconds
+
+require 'appoptics-api-ruby'
+
+Appoptics::Metrics.authenticate 'my email', 'my api key'
+queue = Appoptics::Metrics::Queue.new
+
+def sleep_until(time)
+  secs = time - Time.now
+  puts "sleeping for #{secs}"
+  sleep secs
+end
+
+loop do
+  start = Time.now
+
+  queue.add 'my.metric' => 1234
+  # do work, add more metrics..
+
+  begin
+    queue.submit
+  rescue Exception => e
+    $stderr.puts e
+  end
+
+  sleep_until(start+60)
+end

data/lib/appoptics/metrics.rb

@@ -0,0 +1,95 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'base64'
+require 'forwardable'
+
+require 'metrics/aggregator'
+require 'metrics/annotator'
+require 'metrics/client'
+require 'metrics/collection'
+require 'metrics/connection'
+require 'metrics/errors'
+require 'metrics/persistence'
+require 'metrics/queue'
+require 'metrics/smart_json'
+require 'metrics/util'
+require 'metrics/version'
+
+module Appoptics
+
+  # Metrics provides a simple wrapper for the Metrics web API with a
+  # number of added conveniences for common use cases.
+  #
+  # See the {file:README.md README} for more information and examples.
+  #
+  # @example Simple use case
+  #   Appoptics::Metrics.authenticate 'email', 'api_key'
+  #
+  #   # list current metrics
+  #   Appoptics::Metrics.metrics
+  #
+  #   # submit a metric immediately
+  #   Appoptics::Metrics.submit foo: 12712
+  #
+  #   # fetch the last 10 values of foo
+  #   Appoptics::Metrics.get_measurements :foo, count: 10
+  #
+  # @example Queuing metrics for submission
+  #   queue = Appoptics::Metrics::Queue.new
+  #
+  #   # queue some metrics
+  #   queue.add foo: 12312
+  #   queue.add bar: 45678
+  #
+  #   # send the metrics
+  #   queue.submit
+  #
+  # @example Using a Client object
+  #   client = Appoptics::Metrics::Client.new
+  #   client.authenticate 'email', 'api_key'
+  #
+  #   # list client's metrics
+  #   client.metrics
+  #
+  #   # create an associated queue
+  #   queue = client.new_queue
+  #
+  #   # queue up some metrics and submit
+  #   queue.add foo: 12345
+  #   queue.add bar: 45678
+  #   queue.submit
+  #
+  # @note Most of the methods you can call directly on Appoptics::Metrics are
+  #   delegated to {Client} and are documented there.
+  module Metrics
+    extend SingleForwardable
+
+    TYPES = [:counter, :gauge]
+    PLURAL_TYPES = TYPES.map { |type| "#{type}s".to_sym }
+    MIN_MEASURE_TIME = (Time.now-(3600*24*365)).to_i
+
+    # Most of the singleton methods of Appoptics::Metrics are actually
+    # being called on a global Client instance. See further docs on
+    # Client.
+    #
+    def_delegators  :client, :agent_identifier, :annotate,
+                    :api_endpoint, :api_endpoint=, :authenticate,
+                    :connection, :create_snapshot, :delete_metrics,
+                    :faraday_adapter, :faraday_adapter=, :get_composite,
+                    :get_measurements, :get_metric, :get_series,
+                    :get_snapshot, :get_source, :metrics,
+                    :persistence, :persistence=, :persister, :proxy, :proxy=,
+                    :sources, :submit, :update_metric, :update_metrics,
+                    :update_source
+
+    # The Appoptics::Metrics::Client being used by module-level
+    # access.
+    #
+    # @return [Client]
+    def self.client
+      @client ||= Appoptics::Metrics::Client.new
+    end
+
+  end
+end

data/lib/appoptics/metrics/aggregator.rb

@@ -0,0 +1,138 @@
+require 'aggregate'
+require 'metrics/processor'
+
+module Appoptics
+  module Metrics
+
+    # If you are measuring something very frequently you can sample into
+    # an aggregator and it will track and submit a single aggregate
+    # measurement
+    #
+    # @example
+    #   aggregator = Libato::Metrics::Aggregator.new
+    #
+    #   40.times do
+    #     # do work...
+    #     aggregator.add 'work.time' => work_time
+    #   end
+    #
+    #   # send directly
+    #   aggregator.submit
+    #
+    #   # or merge into a queue for submission
+    #   queue.merge!(aggregator)
+    #
+    class Aggregator
+      SEPARATOR = '%%' # must not be in valid tags and/or source criteria
+
+      include Processor
+
+      attr_reader :source
+
+      # @option opts [Integer] :autosubmit_interval If set the aggregator will auto-submit if the given number of seconds has passed when a new metric is added.
+      # @option opts [Boolean] :clear_failures Should the aggregator remove all stored data if it runs into problems with a request? (default: false)
+      # @option opts [Client] :client The client object to use to connect to Metrics. (default: Appoptics::Metrics.client)
+      # @option opts [Time|Integer] :measure_time A default measure_time to use for measurements added.
+      # @option opts [String] :prefix If set will apply the given prefix to all metric names of measurements added.
+      # @option opts [String] :source The default source to use for measurements added.
+      def initialize(opts={})
+        @aggregated = {}
+        setup_common_options(opts)
+      end
+
+      # Add a metric entry to the metric set:
+      #
+      # @example Basic use
+      #   aggregator.add 'request.time' => 30.24
+      #
+      # @example With a custom source
+      #   aggregator.add 'request.time' => {value: 20.52, source: 'staging'}
+      #
+      # @param [Hash] measurements measurements to add
+      # @return [Aggregator] returns self
+      def add(measurements)
+        measurements.each do |metric, data|
+          entry = {}
+          if @prefix
+            metric = "#{@prefix}.#{metric}"
+          end
+          entry[:name] = metric.to_s
+          if data.respond_to?(:each) # hash form
+            validate_parameters(data)
+            value = data[:value]
+            if data[:source]
+              metric = "#{metric}#{SEPARATOR}#{data[:source]}"
+              entry[:source] = data[:source].to_s
+            elsif data[:tags] && data[:tags].respond_to?(:each)
+              metric = Appoptics::Metrics::Util.build_key_for(metric.to_s, data[:tags])
+              entry[:tags] = data[:tags]
+            end
+          else
+            value = data
+          end
+
+          @aggregated[metric] = {} unless @aggregated[metric]
+          @aggregated[metric][:aggregate] ||= Aggregate.new
+          @aggregated[metric][:aggregate] << value
+          @aggregated[metric].merge!(entry)
+        end
+        autosubmit_check
+        self
+      end
+
+      # Returns true if aggregate contains no measurements
+      #
+      # @return [Boolean]
+      def empty?
+        @aggregated.empty?
+      end
+
+      # Remove all queued metrics
+      #
+      def clear
+        @aggregated = {}
+      end
+      alias :flush :clear
+
+      # Returns currently queued data
+      #
+      def queued
+        entries = []
+        multidimensional = has_tags?
+
+        @aggregated.each_value do |data|
+          entry = {
+            name: data[:name],
+            count: data[:aggregate].count,
+            sum: data[:aggregate].sum,
+            # TODO: make float/non-float consistent in the gem
+            min: data[:aggregate].min.to_f,
+            max: data[:aggregate].max.to_f
+            # TODO: expose v.sum2 and include
+          }
+          if data[:source]
+            entry[:source] = data[:source]
+          elsif data[:tags]
+            multidimensional = true
+            entry[:tags] = data[:tags]
+          end
+          multidimensional = true if data[:time]
+          entries << entry
+        end
+        time = multidimensional ? :time : :measure_time
+        req =
+          if multidimensional
+            { measurements: entries }
+          else
+            { gauges: entries }
+          end
+        req[:source] = @source if @source
+        req[:tags] = @tags if has_tags?
+        req[time] = @time if @time
+
+        req
+      end
+
+    end
+  end
+end

data/lib/appoptics/metrics/annotator.rb

@@ -0,0 +1,145 @@
+module Appoptics::Metrics
+
+  # Read & write annotation streams for a given client connection.
+  class Annotator
+
+    # @option options [Client] :client Client instance used to connect to Metrics
+    def initialize(options={})
+      @client = options[:client] || Appoptics::Metrics.client
+    end
+
+    # Creates a new annotation on the annotation stream
+    #
+    # @example Simple annotation
+    #   annotator.add :deployments, 'deployed v45'
+    #
+    # @example Annotation with start and end times
+    #   annotator.add :deployments, 'deployed v56', start_time: start,
+    #                 end_time: end_time
+    #
+    # @example Annotation with a specific source
+    #   annotator.add :deployments, 'deployed v60', source: 'app12'
+    #
+    # @example Annotation with a description
+    #   annotator.add :deployments, 'deployed v61',
+    #                 description: '9b562b2: shipped new feature foo!'
+    #
+    # @example Annotate with automatic start and end times
+    #   annotator.add(:deployments, 'deployed v62') do
+    #     # do work..
+    #   end
+    #
+    def add(stream, title, options={})
+      options[:title] = title
+      options[:start_time] = (options[:start_time] || Time.now).to_i
+      if options[:end_time]
+        options[:end_time] = options[:end_time].to_i
+      end
+      payload = SmartJSON.write(options)
+      response = connection.post("annotations/#{stream}", payload)
+      # will raise exception if not 200 OK
+      event = SmartJSON.read(response.body)
+      if block_given?
+        yield
+        update_event stream, event['id'], end_time: Time.now.to_i
+        # need to get updated representation
+        event = fetch_event stream, event['id']
+      end
+      event
+    end
+
+    # client instance used by this object
+    def client
+      @client
+    end
+
+    # Delete an annotation stream
+    #
+    # @example Delete the 'deployment' annotation stream
+    #  annotator.delete :deployment
+    #
+    def delete(stream)
+      connection.delete do |request|
+        request.url connection.build_url("annotations/#{stream}")
+      end
+      # expects 204, middleware will raise exception otherwise
+      true
+    end
+
+    # Delete an event from a given annotation stream
+    #
+    # @example Delete event with id 42 from 'deployment'
+    #   annotator.delete_event :deployment, 42
+    #
+    def delete_event(stream, id)
+      connection.delete do |request|
+        request.url connection.build_url("annotations/#{stream}/#{id}")
+      end
+      # expects 204, middleware will raise exception otherwise
+      true
+    end
+
+    # Get a list of annotation events on a given annotation stream
+    #
+    # @example See properties of the 'deployments' annotation stream
+    #   annotator.fetch :deployments
+    #
+    # @example Get events on 'deployments' between start and end times
+    #   annotator.fetch :deployments, start_time: start,
+    #                   end_time: end_time
+    #
+    # @example Source-limited listing
+    #   annotator.fetch :deployments, sources: ['foo','bar','baz'],
+    #                   start_time: start, end_time: end_time
+    #
+    def fetch(stream, options={})
+      response = connection.get("annotations/#{stream}", options)
+      SmartJSON.read(response.body)
+    end
+
+    # Get properties for a given annotation stream event
+    #
+    # @example Get event
+    #   annotator.fetch :deployments, 23
+    #
+    def fetch_event(stream, id)
+      response = connection.get("annotations/#{stream}/#{id}")
+      SmartJSON.read(response.body)
+    end
+
+    # List currently existing annotation streams
+    #
+    # @example List all annotation streams
+    #   streams = annotator.list
+    #
+    # @example List annotator streams with 'deploy' in the name
+    #   deploy_streams = annotator.list name: 'deploy'
+    #
+    def list(options={})
+      response = connection.get("annotations", options)
+      SmartJSON.read(response.body)
+    end
+
+    # Update an event's properties
+    #
+    # @example Set an end time for a previously submitted event
+    #   annotator.update_event 'deploys', 'v24', end_time: end_time
+    #
+    def update_event(stream, id, options={})
+      url = "annotations/#{stream}/#{id}"
+      connection.put do |request|
+        request.url connection.build_url(url)
+        request.body = SmartJSON.write(options)
+      end
+      # expects 204 will raise exception otherwise
+    end
+
+    private
+
+    def connection
+      client.connection
+    end
+
+  end
+
+end