reliquary 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd7b4983647c7844274ae58e7c83edd4f79ea230
+  data.tar.gz: 8e1720e417896b6fbdcd40e2c2b903da3b063f54
+SHA512:
+  metadata.gz: da305a3cb590bf6bb501f13935b47132f80b49e414babd5740a0ae53553f4f3a32ba325438b1407585e8491e518a3c2d9264c7c10192ebe190a96a06df9093f1
+  data.tar.gz: 667f4704fd9645da4b88ca490010e1a4a6524d0c177a544339a3c1e4ee020a5a303450b44932f26ac1b7f8ee613dadc1706354372614c766cc54bfb2741cfcef

data/.gitignore

@@ -0,0 +1,52 @@
+### https://raw.github.com/github/gitignore/94043d7fc7adf554c69355daeb75e2c97ccd7671/Ruby.gitignore
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+.env
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.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
+
+
+### https://raw.github.com/github/gitignore/94043d7fc7adf554c69355daeb75e2c97ccd7671/Global/Vim.gitignore
+
+# swap
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+# session
+Session.vim
+# temporary
+.netrwhist
+*~
+# auto-generated tag files
+tags
+
+

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.2.4

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.11.2

data/.yardopts

@@ -0,0 +1 @@
+--no-private lib/**/*.rb - CODE_OF_CONDUCT.md LICENSE.txt

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at steve.huff@runkeeper.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in reliquary.gemspec
+group :production do
+  gem "chronic", "~> 0.10"
+  gem "multi_json", "~> 1.11"
+  gem "oj", "~> 2.15"
+  gem "rest-client", "~> 1.8"
+end
+
+group :development,:test do
+  gem "awesome_print", "~> 1.6"
+  gem "bond", "~> 0.5"
+  gem "binding_of_caller", "~> 0.7"
+  gem "bundler", "~> 1.11"
+  gem "dotenv", "~> 2"
+  gem "irbtools", require: "irbtools/binding"
+  gem "rake", "~> 10.0"
+  gem "rspec", "~> 3.0"
+  gem "yard", "~> 0.8"
+end

data/Gemfile.lock

@@ -0,0 +1,116 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.6.1)
+    binding.repl (3.0.0)
+    binding_of_caller (0.7.2)
+      debug_inspector (>= 0.0.1)
+    bond (0.5.1)
+    cd (1.0.1)
+    chronic (0.10.2)
+    clipboard (1.1.0)
+    code (0.9.0)
+      coderay (~> 1.1)
+      method_source (~> 0.8, >= 0.8.2)
+    coderay (1.1.1)
+    debug_inspector (0.0.2)
+    debugging (1.1.0)
+      binding.repl (~> 3.0)
+      paint (>= 0.9, < 2.0)
+    diff-lcs (1.2.5)
+    domain_name (0.5.20160310)
+      unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.1.1)
+    every_day_irb (2.0.0)
+      cd (~> 1.0)
+    fancy_irb (1.0.2)
+      paint (>= 0.9, < 2.0)
+      unicode-display_width (~> 1.0)
+    ffi (1.9.10)
+    hirb (0.7.3)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    instance (0.2.0)
+    interactive_editor (0.0.10)
+      spoon (>= 0.0.1)
+    irbtools (2.0.1)
+      binding.repl (~> 3.0)
+      clipboard (~> 1.0, >= 1.0.6)
+      code (~> 0.9)
+      coderay (~> 1.1)
+      debugging (~> 1.1)
+      every_day_irb (~> 2.0)
+      fancy_irb (~> 1.0)
+      hirb (~> 0.7, >= 0.7.3)
+      instance (~> 0.2)
+      interactive_editor (~> 0.0, >= 0.0.10)
+      method_locator (~> 0.0, >= 0.0.4)
+      methodfinder (~> 2.0)
+      ori (~> 0.1.0)
+      os (~> 0.9)
+      paint (>= 0.9, < 2.0)
+      ruby_engine (~> 1.0)
+      ruby_info (~> 1.0)
+      ruby_version (~> 1.0)
+      wirb (~> 2.0)
+    method_locator (0.0.4)
+    method_source (0.8.2)
+    methodfinder (2.0.0)
+    mime-types (2.99.1)
+    multi_json (1.11.3)
+    netrc (0.11.0)
+    oj (2.15.0)
+    ori (0.1.0)
+    os (0.9.6)
+    paint (1.0.1)
+    rake (10.5.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    ruby_engine (1.0.1)
+    ruby_info (1.0.1)
+    ruby_version (1.0.1)
+    spoon (0.0.4)
+      ffi
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.2)
+    unicode-display_width (1.0.3)
+    wirb (2.0.0)
+      paint (>= 0.9, < 2.0)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print (~> 1.6)
+  binding_of_caller (~> 0.7)
+  bond (~> 0.5)
+  bundler (~> 1.11)
+  chronic (~> 0.10)
+  dotenv (~> 2)
+  irbtools
+  multi_json (~> 1.11)
+  oj (~> 2.15)
+  rake (~> 10.0)
+  rest-client (~> 1.8)
+  rspec (~> 3.0)
+  yard (~> 0.8)
+
+BUNDLED WITH
+   1.11.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Steve Huff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# Reliquary [![Gem Version](https://badge.fury.io/rb/reliquary.svg)](https://badge.fury.io/rb/reliquary)
+
+Reliquary is a client for the [New Relic REST API v2](https://docs.newrelic.com/docs/apis/rest-api-v2).  It provides an alternative to the deprecated [newrelic_api](https://github.com/newrelic/newrelic_api) gem.
+
+## TL;DR
+
+```shell
+$ export NEWRELIC_API_KEY='<your API key>'
+```
+
+```ruby
+apps = Reliquary::API::Applications.new
+
+my_app = apps.list(name: 'My App')
+
+my_app[0][:id]
+#=> 123467
+
+apps.list(lang: :java).collect {|app| app[:name]}.sort
+#=> <sorted list of your Java apps' names>
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'reliquary'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install reliquary
+
+## Usage
+
+The New Relic REST API v2 has the following sections (after each section is the minimum version of Reliquary implementing that section):
+
+* Alerts Channels
+* Alerts Events
+* Alerts External Service Conditions
+* Alerts Incidents
+* Alerts Plugins Conditions
+* Alerts Policies
+* Alerts Policy Channels
+* Alerts Synthetics Conditions
+* Alerts Violations
+* Application Hosts
+* Application Instances
+* Applications (0.1.0)
+* Browser Applications
+* Components
+* Key Transactions (0.1.0)
+* Labels
+* Legacy Alert Policies
+* Mobile Applications
+* Notification Channels
+* Plugins
+* Servers
+* Usages
+* Users
+
+For some reason the [API Explorer](https://rpm.newrelic.com/api/explore) does not sort these categories lexically.  I'll update this document as I implement additional sections of the API.
+
+Each section of the API is implemented as a class under the `Reliquary::API` namespace.  Each of these classes exposes methods corresponding to the API methods described by the API Explorer.  When methods take parameters (required or optional), pass them in as a typical params hash.
+
+Access to the API requires an [API key](https://docs.newrelic.com/docs/apis/rest-api-v2/requirements/api-keys).  Reliquary reads your API key at runtime from the `NEWRELIC_API_KEY` environment variable.  If you really want to provide your API key via some other method, or change the API key while the program is running, then you'll need to create your own instance of `Reliquary::Client` with a different API key and then pass it in when initializing instances of the API section classes.
+
+## Development
+
+* write tests
+* handle HTTP error codes
+* implement additional API sections
+* fix YARDoc errors
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hakamadare/reliquary. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "yard"
+
+RSpec::Core::RakeTask.new(:spec)
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', 'lib/**/**/*.rb']   # optional
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+Bundler.setup(:default,:production,:development)
+
+require "dotenv"
+Dotenv.load
+
+require "debugging/all"
+
+loaddirs = [
+  ['.', 'lib'],
+]
+
+loaddirs.each do |path|
+  libdir = File.join(path)
+  $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+end
+
+require "reliquary"
+
+# 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,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/reliquary.rb

@@ -0,0 +1,6 @@
+require "reliquary/version"
+
+module Reliquary
+  autoload :API, 'reliquary/api'
+  autoload :Client, 'reliquary/client'
+end

data/lib/reliquary/api.rb

@@ -0,0 +1,9 @@
+module Reliquary
+  module API
+
+    autoload :Applications, 'reliquary/api/applications'
+    autoload :KeyTransactions, 'reliquary/api/key_transactions'
+    autoload :Base, 'reliquary/api/base'
+
+  end
+end

data/lib/reliquary/api/applications.rb

@@ -0,0 +1,206 @@
+# @markup markdown
+# @title Reliquary::API::Applications
+# @author Steve Huff
+#
+
+module Reliquary
+  module API
+    class Applications < Reliquary::API::Base
+
+      # URI fragment for Applications API endpoint
+      URI_FRAGMENT = 'applications.json'
+
+      # URI method for Applications API endpoint
+      URI_METHOD = :get
+
+      # How to parameterize queries against API endpoint
+      # These are for parameters to be added to the query; some endpoints
+      #   require additional parameters to build the URI fragment.
+      METHOD_PARAMS = {
+        :list           => {
+          :name         => {
+            :key        => 'filter[name]',
+          },
+          :ids          => {
+            :key        => 'filter[ids]',
+            :transform  => lambda {|x| x.join(',')},
+          },
+          :host         => {
+            :key        => 'filter[host]',
+          },
+          :lang         => {
+            :key        => 'filter[language]',
+          },
+          :page         => {},
+        },
+        :show           => {},
+        :metric_names   => {
+          :name         => {},
+          :page         => {},
+        },
+        :metric_data    => {
+          :name         => {},
+          :page         => {},
+          :values       => {
+            :key        => 'values[]',
+            :transform  => lambda {|x| x.join(',')},
+          },
+          :from         => {
+            :munge      => lambda {|x| self.parse_time(x)},
+            :transform  => lambda {|x| self.format_time(x)},
+          },
+          :to           => {
+            :munge      => lambda {|x| self.parse_time(x)},
+            :transform  => lambda {|x| self.format_time(x)},
+          },
+          :period       => {
+            :transform  => lambda {|x| x.to_i},
+          },
+          :summarize    => {
+            :transform  => lambda {|x| x ? 'true' : 'false'},
+          },
+          :raw          => {
+            :transform  => lambda {|x| x ? 'true' : 'false'},
+          },
+        },
+        :update         => {},
+        :delete         => {},
+      }
+
+      # @!method list
+      # List applications, optionally filtering by name or ID
+      # @param [Hash] params parameters for listing
+      # @option [String] :name New Relic application name to select
+      # @option [Array<String>] :ids New Relic application IDs to select
+      # @option [String] :host New Relic application host to select
+      # @option [String] :lang New Relic application language to select
+      #
+      def list(params = {})
+        begin
+          # this is the "default" Applications method, no overrides
+          api_params = {}
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method show
+      # Show summary for a single application
+      # @param [Hash] params parameters for listing
+      # @option params [Integer] :id New Relic application ID
+      def show(params = {})
+        begin
+          id = retrieve_id(params)
+
+          # HTTP method is the default GET
+          # override the URI fragment
+          api_params = { :uri_fragment => "applications/#{id}.json" }
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method metric_names
+      # List metric names for a single application
+      # @param [Hash] params parameters for listing
+      # @option params [Integer] :id New Relic application ID
+      def metric_names(params = {})
+        begin
+          id = retrieve_id(params)
+
+          # HTTP method is the default GET
+          # override the URI fragment
+          api_params = { :uri_fragment => "applications/#{id}/metrics.json" }
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method metric_data
+      # List metric date for a single application
+      # @param [Hash] params parameters for listing
+      # @option params [Integer] :id New Relic application ID
+      # @option params [Array<String>] :names Names of metrics to retrieve
+      # @option params [Array<String>] :values Names of metric values to retrieve
+      # @option params [Time] :from Retrieve metrics after this time
+      # @option params [Time] :to Retrieve metrics before this time
+      # @option params [Time] :period Period of timeslices in seconds
+      # @option params [Boolean] :summarize Return summarized data or all the samples
+      # @option params [Boolean] :raw Return unformatted data
+      def metric_data(params = {})
+        begin
+          id = retrieve_id(params)
+
+          names_param = params.fetch(:names).collect {|x| x.to_s}.join("\n")
+
+          raise "you must supply one or more New Relic metric names" if names_param.nil?
+
+          # HTTP method is the default GET
+          # override the URI fragment
+          api_params = { :uri_fragment => "applications/#{id}/metrics/data.json" }
+
+          execute(api_params, {:params => process_request_params(__method__, params).merge({'names[]' => names_param})})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method update
+      # Update certain parameters of an application
+      # @param [Hash] params parameters for update
+      def update(params = {})
+        begin
+          id = retrieve_id(params)
+
+          raise "not implemented yet"
+
+          # FIXME build the JSON payload
+
+          # HTTP method is PUT
+          # override the URI fragment
+          api_params = {
+            :uri_method => :put,
+            :uri_fragment => "applications/#{id}.json",
+          }
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method delete
+      # Delete an application and all data
+      # @param [Hash] params parameters for delete
+      def delete(params = {})
+        begin
+          id = retrieve_id(params)
+
+          # HTTP method is PUT
+          # override the URI fragment
+          api_params = {
+            :uri_method => :delete,
+            :uri_fragment => "applications/#{id}.json",
+          }
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/reliquary/api/base.rb

@@ -0,0 +1,241 @@
+# @markup markdown
+# @title Reliquary::API::Base
+# @author Steve Huff
+#
+require 'chronic'
+
+module Reliquary
+  module API
+    # @abstract
+    class Base
+
+      # @!attribute [r] client
+      #   @return [Reliquary::Client] the API client to be used for requests
+      attr_reader :client
+
+      # @!attribute [r] uri_fragment
+      #   @return [String] URI fragment defining the API endpoint
+      attr_reader :uri_fragment
+
+      # @!attribute [r] uri_method
+      #   @return [Symbol] default URI method to be used for requests to the API endpoint
+      attr_reader :uri_method
+
+      # @!method initialize(params = {})
+      # Constructor method for base API component
+      # @param [Hash] params parameters for component
+      # @option params [Reliquary::Client] :client (see client)
+      # @option params [String] :uri_fragment (see uri_fragment)
+      # @option params [String] :uri_method (see uri_method)
+      def initialize(params = {})
+        begin
+          client = params[:client]
+          client = Reliquary::Client.new unless client.kind_of? Reliquary::Client
+          @client = client
+
+          uri_fragment = params[:uri_fragment]
+          uri_fragment = self.class::URI_FRAGMENT unless uri_fragment.kind_of? String
+          @uri_fragment = uri_fragment
+
+          uri_method = params[:uri_method]
+          uri_method = self.class::URI_METHOD unless uri_method.kind_of? String
+          @uri_method = uri_method
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method execute(*args, &block)
+      # Execute a HTTP request using the API client
+      # @param [Hash] params parameters for request
+      # @option params [Symbol] :uri_method (see uri_method)
+      # @option params [String] :uri_fragment (see uri_fragment)
+      # @param [Array] args parameters for request
+      # @param [Proc] block block to which request will yield
+      def execute(params, *args, &block)
+        begin
+          raise "params must be a Hash" unless params.kind_of? Hash
+
+          uri_fragment = params.fetch(:uri_fragment, self.uri_fragment)
+          uri_method = params.fetch(:uri_method, self.uri_method)
+
+          resp = self.client[uri_fragment].send(uri_method, *args, &block)
+
+          # FIXME check HTTP response code here
+
+          self.client.parse(resp)
+
+        rescue MultiJson::ParseError => e
+          raise "unable to parse JSON: #{e.message}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method method_params
+      # Return the data structure describing the parameters for modifying a
+      #   particular API method's queries
+      # @param [Symbol] method_name API method
+      # @return [Hash] immutable hash of query params for the API method
+      # @class
+      def self.method_params(method_name)
+        begin
+          self::METHOD_PARAMS.fetch(method_name.to_sym).freeze
+
+        rescue KeyError => e
+          raise "'#{method_name}' does not look like an API method implemented by #{self}: #{e.message}"
+
+        rescue NameError => e
+          raise "#{self} does not appear to have implemented query params: #{e.message}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      protected
+
+      # @!method retrieve_id
+      # Retrieve New Relic ID from a params hash
+      # @param [Hash] params Hash of parameters
+      # @param [Symbol] id_key Hash key associated with ID value (default `:id`)
+      # @return [Integer] New Relic ID
+      def retrieve_id(params, id_key = :id)
+        begin
+          id_val = params.fetch(id_key.to_sym)
+
+          if id_val.nil?
+            raise "you must supply a New Relic application ID"
+          else
+            id_val.to_i
+          end
+
+        rescue NoMethodError => e
+          raise "unable to convert '#{id_val.inspect}' to integer: #{e.message}"
+
+        rescue KeyError => e
+          raise "the params hash has no key called '#{id_key}': #{e.message}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method process_request_params
+      # Iterate over an API method's parameters, building up a hash of URI
+      #   query parameters that will be added to the REST API query.
+      # @param [Symbol] api_method The REST API method that is being called
+      # @param [Hash] query_params The modifications to be made to this
+      #   particular REST API request
+      # @return [Hash] parameters to be passed to execute() method
+      def process_request_params(api_method, query_params)
+        begin
+          this_methods_params = self.class.method_params(api_method.to_sym)
+
+          request_params = {}
+
+          this_methods_params.keys.each do |k|
+            request_params = build_request_params(request_params: request_params, method_param: k.to_sym, param_value: query_params[k.to_sym], method_params: this_methods_params)
+          end
+
+          request_params
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method build_request_params
+      # API requests optionally take parameters that modify their behavior;
+      #   calling this method builds up a hash of the parameters that will be
+      #   passed to the request.  Essentially, it translates Ruby parameters
+      #   into the literal strings that will be appended to the HTTP request.
+      # @param [Hash] params Parameters for this method
+      # @option params [Hash] :request_params Accumulated API request parameters
+      # @option params [Symbol] :method_param
+      # @option params [Symbol] :param_value
+      # @option params [Symbol] :method_params
+      # @return [Hash] (see :request_params)
+      def build_request_params(params)
+
+        begin
+          # these are the parameters that will eventually be passed to the REST
+          # API request; expect these to accumulate over multiple invocations
+          # of this method.  You must return this hash, either modified or
+          # unmodified.
+          request_params = params.fetch(:request_params)
+
+          # this is a Symbol representing the type of modification that will be
+          # made to the API request; it's a lookup key
+          method_param = params.fetch(:method_param)
+
+          # this is a String representing the parameter that will be passed to
+          # the API request modification (_e.g._ if the modification is "filter
+          # by language type", this value specifies the language type)
+          param_value = params.fetch(:param_value)
+
+          # this is a Hash specifying the API parameter being built
+          method_params = params.fetch(:method_params)
+
+          this_requests_params = method_params.fetch(method_param)
+
+          if param_value.nil?
+            request_params
+          else
+            # default param key is the method param, stringified
+            param_key = this_requests_params.fetch(:key, method_param.to_s)
+
+            param_transform = this_requests_params.fetch(:transform, lambda {|x| x.to_s})
+            param_munge = this_requests_params.fetch(:munge, lambda {|x| x})
+
+            request_params.store(param_key.to_s, param_transform.call(param_munge.call(param_value)))
+
+            request_params
+          end
+
+        rescue KeyError => e
+          raise "unable to find filter options for API method '#{api_method}': #{e.message}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @! method parse_time
+      # Parses and validates a time parameter (accepts ISO8601 format and some
+      # "natural language" formats), converting to UTC
+      # @param [String] time String to be parsed
+      # @return [Time] parsed Time object
+      def self.parse_time(time)
+        begin
+          Chronic.parse(time).utc
+
+        rescue NoMethodError => e
+          raise "unable to parse '#{time}' as a time: #{e.message}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @! method format_time
+      # Converts a Time object to an ISO8601-formatted String, forcing UTC
+      # @param [Time] time Time object to be formatted
+      # @return [String] formatted String
+      def self.format_time(time)
+        begin
+          time.utc.strftime('%FT%T') + '+00:00'
+
+        rescue NoMethodError => e
+          raise "unable to parse '#{time}' as a time: #{e.message}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/reliquary/api/key_transactions.rb

@@ -0,0 +1,73 @@
+# @markup markdown
+# @title Reliquary::API::KeyTransactions
+# @author Steve Huff
+#
+
+module Reliquary
+  module API
+    class KeyTransactions < Reliquary::API::Base
+
+      # URI fragment for Applications API endpoint
+      URI_FRAGMENT = 'key_transactions.json'
+
+      # URI method for Applications API endpoint
+      URI_METHOD = :get
+
+      # How to parameterize queries against API endpoint
+      # These are for parameters to be added to the query; some endpoints
+      #   require additional parameters to build the URI fragment.
+      METHOD_PARAMS = {
+        :list           => {
+          :name         => {
+            :key        => 'filter[name]',
+          },
+          :ids          => {
+            :key        => 'filter[ids]',
+            :transform  => lambda {|x| x.join(',')},
+          },
+          :page         => {},
+        },
+        :show           => {},
+      }
+
+      # @!method list
+      # List key transactions, optionally filtering by name or ID
+      # @param [Hash] params parameters for listing
+      # @option [String] :name New Relic key transaction name to select
+      # @option [Array<String>] :ids New Relic key transaction policy IDs to select
+      #
+      def list(params = {})
+        begin
+          # this is the "default" Key Transactions method, no overrides
+          api_params = {}
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      # @!method show
+      # Show summary for a single key transaction
+      # @param [Hash] params parameters for listing
+      # @option params [Integer] :id New Relic key transaction ID
+      def show(params = {})
+        begin
+          id = retrieve_id(params)
+
+          # HTTP method is the default GET
+          # override the URI fragment
+          api_params = { :uri_fragment => "key_transactions/#{id}.json" }
+
+          execute(api_params, {:params => process_request_params(__method__, params)})
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+
+    end
+  end
+end

data/lib/reliquary/client.rb

@@ -0,0 +1,116 @@
+# @markup markdown
+# @title Reliquary::Client
+# @author Steve Huff
+#
+
+require 'multi_json'
+require 'rest-client'
+require 'uri'
+
+module Reliquary
+  class Client
+
+    HTTP_METHODS = ['get','put','post','patch','delete','head']
+
+    # @!attribute [r] api_key
+    #   @return [String] a [New Relic REST API](https://rpm.newrelic.com/api/explore) key
+    attr_reader :api_key
+
+    # @!attribute [r] api_base
+    #   @return [URI] the base URI on which additional REST calls will be built
+    attr_reader :api_base
+
+    # @!method initialize(api_key = ENV['NEWRELIC_API_KEY'])
+    #   Constructor method
+    #   @param api_key [String] (see api_key)
+    #   @return [Reliquary::Client] the initialized client
+    #
+    def initialize(api_key = ENV['NEWRELIC_API_KEY'])
+      begin
+        @api_key = validate_api_key(api_key)
+        @api_base = build_api_base('https://api.newrelic.com/v2/')
+
+      rescue NoMethodError => e
+        false
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+    # @!method parse(json)
+    #   Parse returned JSON into a Ruby object
+    #
+    #   @param [String] json JSON-formatted string
+    #   @return [Object] Ruby object representing JSON-formatted string
+    def parse(json)
+      begin
+        # strip off some layers of nonsense added by Oj
+        MultiJson.load(json, :symbolize_keys => true).values[0]
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+    # @!method method_missing(method_name, *args, &block)
+    #   Delegate HTTP method calls to RestClient::Resource
+    #
+    #   @param method_name [Symbol] name of method (must be a member of
+    #     {Reliquary::Client::HTTP_METHODS})
+    #   @param args [Array] additional method params
+    #   @param block [Proc] block to which method will yield
+    def method_missing(method_name, *args, &block)
+      begin
+        self.api_base.send(method_name.to_sym, *args, &block)
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      HTTP_METHODS.include?(method_name.to_s) || super
+    end
+
+    private
+
+    def build_api_base(uri)
+      begin
+        validated_uri = URI(uri)
+
+        RestClient::Resource.new(validated_uri.to_s, :headers => auth_header)
+
+      rescue URI::InvalidURIError => e
+        raise "'#{uri}' does not look like a valid URI"
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+
+    def validate_api_key(api_key)
+      begin
+        if /^[\h]{47}$/ =~ api_key
+          api_key
+        else
+          raise "'#{api_key}' does not look like a valid New Relic REST API key"
+        end
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+    def auth_header(api_key = self.api_key)
+      begin
+        {:x_api_key => api_key}
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+  end
+end

data/lib/reliquary/version.rb

@@ -0,0 +1,3 @@
+module Reliquary
+  VERSION = "0.1.0"
+end

data/reliquary.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reliquary/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "reliquary"
+  spec.version       = Reliquary::VERSION
+  spec.authors       = ["Steve Huff"]
+  spec.email         = ["shuff@vecna.org"]
+
+  spec.summary       = %q{Client for New Relic API v2.}
+  spec.description   = %q{The official New Relic Ruby gem only supports API v1.}
+  spec.homepage      = "https://github.com/hakamadare/rubygem-reliquary"
+  spec.license       = "MIT"
+
+  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"]
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: reliquary
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Steve Huff
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-27 00:00:00.000000000 Z
+dependencies: []
+description: The official New Relic Ruby gem only supports API v1.
+email:
+- shuff@vecna.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- ".yardopts"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/reliquary.rb
+- lib/reliquary/api.rb
+- lib/reliquary/api/applications.rb
+- lib/reliquary/api/base.rb
+- lib/reliquary/api/key_transactions.rb
+- lib/reliquary/client.rb
+- lib/reliquary/version.rb
+- reliquary.gemspec
+homepage: https://github.com/hakamadare/rubygem-reliquary
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Client for New Relic API v2.
+test_files: []
+has_rdoc: