signalfx 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5fa0fd8975ae62bdd02d8bd289c8b76e62f79031
+  data.tar.gz: 2615a0bd2a102874a11312e6af172d4bcf76c0a0
+SHA512:
+  metadata.gz: 98412f576fa8e655e14ef784adb852414414dde3dc0a34440435ed8f5cf3871e419610c4cbf258a4a0d9c23c610341304ba8c45ae39cc8caf89d52ebe78e66fa
+  data.tar.gz: 31eb6b8efc37a5e9f6af6b73a3de4a7d5da2d37f5b4b9aa06c5c79bf05a61429c8fe0c60d542ecf529420d1b70bcffd6a6df71700d4cc5273aa8ad4ef987db10

data/.gitignore

@@ -0,0 +1,43 @@
+### IDEA
+.idea
+*.iml
+
+### Ruby template
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Created by .ignore support plugin (hsz.mobi)

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: required
+language: ruby
+
+rvm:
+  - 2.1.0
+  - 2.2.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in signalfx.gemspec
+gemspec
+
+source 'https://rubygems.org'
+
+gem 'simplecov', :require => false, :group => :test

data/Gemfile.lock

@@ -0,0 +1,84 @@
+PATH
+  remote: .
+  specs:
+    signalfx (0.1.0)
+      protobuf (~> 3.5.1, >= 3.5.1)
+      rest-client (~> 1.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.8)
+    crack (0.4.2)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    domain_name (0.5.25)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    middleware (0.1.0)
+    mime-types (2.6.2)
+    minitest (5.8.0)
+    netrc (0.10.3)
+    protobuf (3.5.1)
+      activesupport (>= 3.2)
+      middleware
+      thor
+      thread_safe
+    rake (10.4.2)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    safe_yaml (1.0.4)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+    webmock (1.21.0)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  rake (~> 10.0)
+  rspec
+  signalfx!
+  simplecov
+  webmock (~> 1.21)
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -0,0 +1,139 @@
+# Ruby client library for SignalFx
+
+This is a programmatic interface in Ruby for SignalFx's metadata and ingest APIs. It is meant to provide a base for communicating with SignalFx APIs that can be easily leveraged by scripts and applications to interact with SignalFx or report metric and event data to SignalFx.
+Library supports Ruby 2.x versions
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'signalfx'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install signalfx
+
+## Usage
+
+### API access token
+
+To use this library, you need a SignalFx API access token, which can be obtained from the SignalFx organization you want to report data into.
+
+### Create client
+
+The default constructor `SignalFx` uses Protobuf to send data to SignalFx. If it cannot send Protobuf, it falls back to sending JSON.
+
+```ruby
+require('signalfx');
+
+// Create client
+client = SignalFx.new 'MY_SIGNALFX_TOKEN';
+```
+
+Optional constructor parameters:
++ **api_token** - Your private SignalFx token
++ **enable_aws_unique_id** - boolean, `false` by default.
+       If `true`, library will retrieve Amazon unique identifier
+       and set it as `AWSUniqueId` dimension for each datapoint and event.
+       Use this option only if your application deployed to Amazon
++ **ingest_endpoint** - string
++ **api_endpoint** - string
++ **timeout** - number
++ **batch_size** - number
++ **user_agents** - array
+
+### Reporting data
+
+This example shows how to report metrics to SignalFx, as gauges, counters, or cumulative counters. 
+
+```ruby
+require('signalfx');
+
+client = SignalFx.new 'MY_SIGNALFX_TOKEN';
+
+client.send(
+           cumulative_counters:[
+             {  :metric => 'myfunc.calls_cumulative', 
+                :value => 10, 
+                :timestamp => 1442960607000 },
+             ...
+           ],
+           gauges:[
+             {  :metric => 'myfunc.time', 
+                :value => 532, 
+                :timestamp => 1442960607000},
+             ...
+           ],
+           counters:[
+             {  :metric => 'myfunc.calls', 
+                :value => 42, 
+                :timestamp => 1442960607000},
+             ...
+           ]);
+```
+The `timestamp` must be a millisecond precision timestamp; the number of milliseconds elapsed since Epoch. The `timestamp` field is optional, but strongly recommended. If not specified, it will be set by SignalFx's ingest servers automatically; in this situation, the timestamp of your datapoints will not accurately represent the time of their measurement (network latency, batching, etc. will all impact when those datapoints actually make it to SignalFx).
+
+### Sending multi-dimensional data
+
+Reporting dimensions for the data is also optional, and can be accomplished by specifying a `dimensions` parameter on each datapoint containing a dictionary of string to string key/value pairs representing the dimensions:
+
+
+```ruby
+require('signalfx');
+
+client = SignalFx.new 'MY_SIGNALFX_TOKEN';
+
+client.send(
+          cumulative_counters:[
+            {   :metric => 'myfunc.calls_cumulative', 
+                :value => 10, 
+                :dimensions => [{:key => 'host', :value => 'server1'}]},
+            ...
+          ],
+          gauges:[
+            {   :metric => 'myfunc.time', 
+                :value=> 532, 
+                :dimensions=> [{:key => 'host', :value => 'server1'}]},
+            ...
+          ],
+          counters:[
+            {   :metric=> 'myfunc.calls', 
+                :value=> 42, 
+                :dimensions=> [{:key => 'host', :value => 'server1'}]},
+            ...
+          ]);
+```
+See `examples/generic_usecase.py` for a complete code example for Reporting data.
+
+### Sending events
+
+Events can be sent to SignalFx via the `send_event` function. The
+event type must be specified, and dimensions and extra event properties
+can be supplied as well.
+
+
+```ruby
+require('signalfx');
+
+client = SignalFx.new 'MY_SIGNALFX_TOKEN';
+
+client.send_event(
+          '[event_type]',
+          {
+              host: 'myhost',
+              service: 'myservice',
+              instance: 'myinstance'
+          },
+          properties={
+              version: 'event_version'})
+```
+
+See `examples/generic_usecase.py` for a complete code example for Reporting data.
+
+## License
+
+Apache Software License v2 © [SignalFx](https://signalfx.com)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "signalfx"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/generic_usecase.rb

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require './lib/signalfx'
+
+puts 'SignalFx metrics reporting demo:'
+token = ARGV[0] # Your SignalFx API access token
+if token.nil? || token.empty?
+  puts '
+        SignalFx API access token not defined. Please specify token in command line.
+            $ ./generic_usecase.rb YOUR_TOKEN
+
+        '
+  exit 0
+end
+
+
+#create client instance with SignalFx API access token
+client = SignalFx.new token, enable_aws_unique_id: false, timeout: 3000
+
+puts 'SignalFx metrics reporting demo:'
+#run loop to send datapoints to SignalFx
+counter = 0
+while true do
+  puts "Send datapoints ##{counter}"
+  timestamp = (Time.now.to_i * 1000).to_i
+  gauges = [{:metric => 'test.cpu', :value => counter % 10, :timestamp => timestamp}]
+  counters = [{:metric => 'cpu_cnt', :value => counter % 2, :timestamp => timestamp}]
+
+  client.send(gauges: gauges, counters: counters)
+
+  if counter % 100 == 0
+    event_type = 'deployments'
+    version = Time.now.strftime("%Y-%m-%d") + '-' + counter.to_s
+    dimensions =
+        {host: 'myhost',
+         service: 'myservice',
+         instance: 'myinstance'}
+    properties = {version: version}
+
+
+    client.send_event(event_type, dimensions: dimensions, properties: properties)
+  end
+
+  counter +=1
+  sleep(1)
+end

data/lib/proto/signal_fx_protocol_buffers.pb.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+module Com
+  module Signalfx
+    module Metrics
+      module Protobuf
+
+        ##
+        # Enum Classes
+        #
+        class MetricType < ::Protobuf::Enum
+          define :GAUGE, 0
+          define :COUNTER, 1
+          define :ENUM, 2
+          define :CUMULATIVE_COUNTER, 3
+        end
+
+
+        ##
+        # Message Classes
+        #
+        class Datum < ::Protobuf::Message; end
+        class Dimension < ::Protobuf::Message; end
+        class DataPoint < ::Protobuf::Message; end
+        class DataPointUploadMessage < ::Protobuf::Message; end
+        class PointValue < ::Protobuf::Message; end
+
+
+        ##
+        # Message Fields
+        #
+        class Datum
+          optional :string, :strValue, 1
+          optional :double, :doubleValue, 2
+          optional :int64, :intValue, 3
+        end
+
+        class Dimension
+          optional :string, :key, 1
+          optional :string, :value, 2
+        end
+
+        class DataPoint
+          optional :string, :source, 1
+          optional :string, :metric, 2
+          optional :int64, :timestamp, 3
+          optional ::Com::Signalfx::Metrics::Protobuf::Datum, :value, 4
+          optional ::Com::Signalfx::Metrics::Protobuf::MetricType, :metricType, 5
+          repeated ::Com::Signalfx::Metrics::Protobuf::Dimension, :dimensions, 6
+        end
+
+        class DataPointUploadMessage
+          repeated ::Com::Signalfx::Metrics::Protobuf::DataPoint, :datapoints, 1
+        end
+
+        class PointValue
+          optional :int64, :timestamp, 3
+          optional ::Com::Signalfx::Metrics::Protobuf::Datum, :value, 4
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/signalfx.rb

@@ -0,0 +1,43 @@
+# Copyright (C) 2015 SignalFx, Inc. All rights reserved.
+
+require_relative 'signalfx/conf'
+require_relative 'signalfx/protobuf_signal_fx_client'
+require_relative 'signalfx/json_signal_fx_client'
+
+module SignalFx
+
+  # SignalFx API client.
+  # This class presents a programmatic interface to SignalFx's metadata and
+  # ingest APIs. At the time being, only ingest is supported; more will come
+  # later.
+  #
+  # @param api_token - Your private SignalFx token
+  # @param enable_aws_unique_id - boolean, `false` by default.
+  #     If `true`, library will retrieve Amazon unique identifier
+  #     and set it as `AWSUniqueId` dimension for each datapoint and event.
+  #     Use this option only if your application deployed to Amazon
+  # @param ingest_endpoint - string
+  # @param api_endpoint - string
+  # @param timeout - number
+  # @param batch_size - number
+  # @param user_agents - array
+  def self.new(api_token, enable_aws_unique_id: false, ingest_endpoint: Config::DEFAULT_INGEST_ENDPOINT,
+      api_endpoint: Config::DEFAULT_API_ENDPOINT, timeout: Config::DEFAULT_TIMEOUT,
+      batch_size: Config::DEFAULT_BATCH_SIZE, user_agents: [])
+    begin
+      require_relative './proto/signal_fx_protocol_buffers.pb'
+      ProtoBufSignalFx.new(api_token, enable_aws_unique_id: enable_aws_unique_id, ingest_endpoint: ingest_endpoint,
+                           api_endpoint: api_endpoint, timeout: timeout,
+                           batch_size: batch_size, user_agents: user_agents)
+
+    rescue Exception => e
+      puts "Protocol Buffers not installed properly. Switch to JSON.
+            #{e}"
+      JsonSignalFx.new(api_token, enable_aws_unique_id: enable_aws_unique_id, ingest_endpoint: ingest_endpoint,
+                       api_endpoint: api_endpoint, timeout: timeout,
+                       batch_size: batch_size, user_agents: user_agents)
+    end
+
+
+  end
+end

data/lib/signalfx/conf.rb

@@ -0,0 +1,17 @@
+# Copyright (C) 2015 SignalFx, Inc. All rights reserved.
+
+module Config
+# Default Parameters
+  DEFAULT_INGEST_ENDPOINT = 'https://ingest.signalfx.com'
+  DEFAULT_API_ENDPOINT = 'https://api.signalfx.com'
+  DEFAULT_BATCH_SIZE = 300 # Will wait for this many requests before posting
+  DEFAULT_TIMEOUT = 1
+
+# Global Parameters
+  PROTOBUF_HEADER_CONTENT_TYPE = 'application/x-protobuf'
+  JSON_HEADER_CONTENT_TYPE = 'application/json'
+
+  AWS_UNIQUE_ID_URL = 'http://169.254.169.254/2014-11-05/dynamic/instance-identity/document'
+
+  AWS_UNIQUE_ID_DIMENSION_NAME = :AWSUniqueId
+end

data/lib/signalfx/json_signal_fx_client.rb

@@ -0,0 +1,40 @@
+# Copyright (C) 2015 SignalFx, Inc. All rights reserved.
+
+require_relative './signal_fx_client'
+require_relative './conf'
+require 'json'
+
+class JsonSignalFx < SignalFxClient
+
+  protected
+
+  def header_content_type
+    Config::JSON_HEADER_CONTENT_TYPE
+  end
+
+  def add_to_queue(metric_type, datapoint)
+    #set datapoint dimensions
+    dimensions = {}
+    if datapoint[:dimensions] != nil
+      datapoint[:dimensions].each {
+          |dimension| dimensions[dimension[:key]] = dimension[:value]
+      }
+    end
+    datapoint[:dimensions] = dimensions
+    get_queue << {metric_type => datapoint}
+  end
+
+  def batch_data(data_point_list)
+    data = Hash.new
+    data_point_list.each do |datapoint|
+      datapoint.each do |key, value|
+        if data[key] == nil
+          data[key] = []
+        end
+        data[key] << value
+      end
+    end
+
+    data.to_json
+  end
+end

data/lib/signalfx/protobuf_signal_fx_client.rb

@@ -0,0 +1,63 @@
+# Copyright (C) 2015 SignalFx, Inc. All rights reserved.
+
+require 'thread'
+require_relative './conf'
+require_relative './signal_fx_client'
+require_relative '../proto/signal_fx_protocol_buffers.pb'
+
+class ProtoBufSignalFx < SignalFxClient
+
+  protected
+
+  def header_content_type
+    Config::PROTOBUF_HEADER_CONTENT_TYPE
+  end
+
+
+  def add_to_queue(metric_type, datapoint)
+    protobuf_datapoint = Com::Signalfx::Metrics::Protobuf::DataPoint.new
+
+    # assign value type
+    datapoint_value = datapoint[:value]
+    if datapoint_value.kind_of?(String)
+      protobuf_datapoint.value = Com::Signalfx::Metrics::Protobuf::Datum.new :strValue => datapoint_value
+    else
+      if datapoint_value.kind_of?(Float)
+        protobuf_datapoint.value = Com::Signalfx::Metrics::Protobuf::Datum.new :doubleValue => datapoint_value
+      else
+        if datapoint_value.kind_of?(Fixnum)
+          protobuf_datapoint.value = Com::Signalfx::Metrics::Protobuf::Datum.new :intValue => datapoint_value
+        else
+          throw TypeError('Invalid Value ' + datapoint_value);
+        end
+      end
+    end
+
+
+    protobuf_datapoint.metricType = Com::Signalfx::Metrics::Protobuf::MetricType.const_get(metric_type.upcase)
+    protobuf_datapoint.metric = datapoint[:metric]
+    if datapoint[:timestamp] != nil
+      protobuf_datapoint.timestamp = datapoint[:timestamp]
+    end
+
+    #set datapoint dimensions
+    dimensions = Array.new
+    if datapoint[:dimensions] != nil
+      datapoint[:dimensions].each {
+          |dimension| dimensions.push(
+            Com::Signalfx::Metrics::Protobuf::Dimension.new :key => dimension[:key], :value => dimension[:value])
+      }
+    end
+    protobuf_datapoint.dimensions = dimensions
+
+    # add object to queue
+    get_queue. << protobuf_datapoint
+  end
+
+
+  def batch_data(data_point_list)
+    dpum = Com::Signalfx::Metrics::Protobuf::DataPointUploadMessage.new
+    data_point_list.each { |datapoint| dpum.datapoints << datapoint }
+    dpum.to_s
+  end
+end

data/lib/signalfx/signal_fx_client.rb

@@ -0,0 +1,226 @@
+# Copyright (C) 2015 SignalFx, Inc. All rights reserved.
+
+require_relative './version'
+require_relative './conf'
+
+require 'net/http'
+require 'uri'
+require 'openssl'
+require 'rest-client'
+
+class SignalFxClient
+  HEADER_API_TOKEN_KEY = 'X-SF-Token'
+  HEADER_USER_AGENT_KEY = 'User-Agent'
+  HEADER_CONTENT_TYPE = 'Content-Type'
+  INGEST_ENDPOINT_SUFFIX = 'v2/datapoint'
+  API_ENDPOINT_SUFFIX = 'v1/event'
+
+  def initialize(api_token, enable_aws_unique_id: false, ingest_endpoint: Config::DEFAULT_INGEST_ENDPOINT,
+                 api_endpoint: Config::DEFAULT_API_ENDPOINT, timeout: Config::DEFAULT_TIMEOUT,
+                 batch_size: Config::DEFAULT_BATCH_SIZE, user_agents: [])
+
+    @api_token = api_token
+    @ingest_endpoint = ingest_endpoint
+    @api_endpoint = api_endpoint
+    @timeout = timeout
+    @batch_size = batch_size
+    @user_agents = user_agents
+
+    @aws_unique_id = nil
+
+    @queue = Queue.new
+    @async_running = false
+
+    if enable_aws_unique_id
+      retrieve_aws_unique_id { |request|
+        if request != nil
+          json_resp = JSON.parse(request.body)
+          @aws_unique_id = json_resp['instanceId']+'_'+json_resp['region']+'_'+json_resp['accountId']
+          puts("AWS Unique ID loaded: #{@aws_unique_id}")
+        else
+          puts('Failed to retrieve AWS unique ID.')
+        end
+      }
+    end
+    puts('initialize end')
+  end
+
+  #Send the given metrics to SignalFx synchronously.
+  #You can use this method to send data via reporters such as Codahale style libraries
+  #
+  #Args:
+  #    cumulative_counters (list): a list of dictionaries representing the
+  #                 cumulative counters to report.
+  #    gauges (list): a list of dictionaries representing the gauges to report.
+  #    counters (list): a list of dictionaries representing the counters to report.
+  def send(cumulative_counters: nil, gauges: nil, counters: nil)
+    process_datapoint('cumulative_counter', cumulative_counters)
+    process_datapoint('gauge', gauges)
+    process_datapoint('counter', counters)
+
+    data_points_list = []
+    while @queue.length > 0 && data_points_list.length < @batch_size
+      data_points_list << @queue.shift
+    end
+
+    data_to_send = batch_data(data_points_list)
+
+    begin
+      post(data_to_send, @ingest_endpoint, INGEST_ENDPOINT_SUFFIX)
+    ensure
+      @async_running = false
+    end
+  end
+
+  #Send the given metrics to SignalFx asynchronously.
+  #
+  #Args:
+  #    cumulative_counters (list): a list of dictionaries representing the
+  #                 cumulative counters to report.
+  #    gauges (list): a list of dictionaries representing the gauges to report.
+  #    counters (list): a list of dictionaries representing the counters to report.
+  def send_async(cumulative_counters: nil, gauges: nil, counters: nil)
+    process_datapoint('cumulative_counter', cumulative_counters)
+    process_datapoint('gauge', gauges)
+    process_datapoint('counter', counters)
+
+    if @async_running
+      return
+    end
+
+    data_points_list = []
+    while @queue.length > 0 && data_points_list.length < @batch_size
+      data_points_list << @queue.shift
+    end
+
+    data_to_send = batch_data(data_points_list)
+
+    @async_running = true
+
+    Thread.abort_on_exception = true
+    Thread.start {
+      begin
+
+        post(data_to_send, @ingest_endpoint, INGEST_ENDPOINT_SUFFIX){
+          @async_running = false
+        }
+      ensure
+        @async_running = false
+      end
+    }
+  end
+
+
+  #Send an event to SignalFx.
+  #
+  #Args:
+  #    event_type (string): the event type (name of the event time series).
+  #    dimensions (dict): a map of event dimensions.
+  #    properties (dict): a map of extra properties on that event.
+  def send_event(event_type, dimensions: {}, properties: {})
+    data = {
+        eventType: event_type,
+        dimensions: dimensions,
+        properties: properties
+    }
+
+    if @aws_unique_id
+      data[:dimensions][Config::AWS_UNIQUE_ID_DIMENSION_NAME] = @aws_unique_id
+    end
+
+    puts(data)
+
+    post(data.to_json, @api_endpoint, API_ENDPOINT_SUFFIX, Config::JSON_HEADER_CONTENT_TYPE)
+  end
+
+  protected
+
+  def get_queue
+    @queue
+  end
+
+  def header_content_type
+    raise 'Subclasses should implement this!'
+  end
+
+  def add_to_queue(metric_type, datapoint)
+    raise 'Subclasses should implement this!'
+  end
+
+  def batch_data(data_point_list)
+    raise 'Subclasses should implement this!'
+  end
+
+  private
+
+  def post(data_to_send, url, suffix, content_type = nil, &block)
+    begin
+      http_user_agents = ''
+      if @user_agents != nil && @user_agents.length > 0
+        http_user_agents = ', ' + @user_agents.join(', ')
+      end
+
+      headers = {HEADER_CONTENT_TYPE => content_type != nil ? content_type : header_content_type,
+                 HEADER_API_TOKEN_KEY => @api_token,
+                 HEADER_USER_AGENT_KEY => Version::NAME + '/' + Version::VERSION + http_user_agents}
+
+      RestClient::Request.execute(
+          method: :post,
+          url: url + '/' + suffix,
+          headers: headers,
+          payload: data_to_send,
+          verify_ssl: OpenSSL::SSL::VERIFY_NONE,
+          timeout: @timeout) { |response|
+        case response.code
+          when 200
+            if block
+              block.call(response)
+            end
+          else
+            puts "Failed to send datapoints. Response code: #{response.code}"
+            if block
+              block.call(nil)
+            end
+        end
+      }
+    rescue Exception => e
+      puts "Failed to send datapoints. Error: #{e}"
+      if block
+        block.call(nil)
+      end
+    end
+  end
+
+  def retrieve_aws_unique_id(&block)
+    begin
+      RestClient::Request.execute(method: :get, url: Config::AWS_UNIQUE_ID_URL,
+                                  timeout: 1) { |response|
+        case response.code
+          when 200
+            return block.call(response)
+          else
+            puts "Failed to retrieve AWS unique ID. Response code: #{response.code}"
+            return block.call(nil)
+        end
+      }
+    rescue Exception => e
+      puts "Failed to retrieve AWS unique ID. Error: #{e}"
+      block.call(nil)
+    end
+  end
+
+  def process_datapoint(metric_type, data_points)
+    if data_points != nil && data_points.kind_of?(Array)
+      data_points.each { |datapoint|
+        if @aws_unique_id
+          if datapoint[:dimensions] == nil
+            datapoint[:dimensions] = []
+          end
+          datapoint[:dimensions] << {:key => Config::AWS_UNIQUE_ID_DIMENSION_NAME, :value => @aws_unique_id}
+        end
+
+        add_to_queue(metric_type, datapoint)
+      }
+    end
+  end
+end

data/lib/signalfx/version.rb

@@ -0,0 +1,6 @@
+# Copyright (C) 2015 SignalFx, Inc. All rights reserved.
+
+module Version
+  VERSION = '0.1.0'
+  NAME = 'signalfx-ruby-client'
+end

data/signalfx.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require_relative 'lib/signalfx/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "signalfx"
+  spec.version       = Version::VERSION
+  spec.authors       = ["SignalFx, Inc"]
+  spec.email         = ["info@signalfx.com"]
+
+  spec.summary       = "Ruby client library for SignalFx"
+  spec.description   = "This is a programmatic interface in Ruby for SignalFx's metadata and ingest APIs. It is meant to provide a base for communicating with SignalFx APIs that can be easily leveraged by scripts and applications to interact with SignalFx or report metric and event data to SignalFx. Library supports Ruby 2.x versions"
+  spec.homepage      = "https://signalfx.com"
+  spec.license       = "Apache Software License v2 © SignalFx"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata['allowed_push_host'] = "Set to 'http://mygemserver.com'"
+  #else
+  #  raise '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(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock", "~> 1.21"
+  spec.add_dependency "protobuf", "~> 3.5.1", ">= 3.5.1"
+  spec.add_dependency "rest-client", "~> 1.8"
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: signalfx
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- SignalFx, Inc
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.5.1
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.5.1
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.5.1
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: This is a programmatic interface in Ruby for SignalFx's metadata and
+  ingest APIs. It is meant to provide a base for communicating with SignalFx APIs
+  that can be easily leveraged by scripts and applications to interact with SignalFx
+  or report metric and event data to SignalFx. Library supports Ruby 2.x versions
+email:
+- info@signalfx.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/generic_usecase.rb
+- lib/proto/signal_fx_protocol_buffers.pb.rb
+- lib/signalfx.rb
+- lib/signalfx/conf.rb
+- lib/signalfx/json_signal_fx_client.rb
+- lib/signalfx/protobuf_signal_fx_client.rb
+- lib/signalfx/signal_fx_client.rb
+- lib/signalfx/version.rb
+- signalfx.gemspec
+homepage: https://signalfx.com
+licenses:
+- Apache Software License v2 © SignalFx
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Ruby client library for SignalFx
+test_files: []