lm_rest 1.0.1

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'lm_rest'
+
+# 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

data/bin/ds_checker.rb

@@ -0,0 +1,261 @@
+#!/usr/bin/env ruby
+#
+#
+# Based on a script written originally by Matt Dunham
+#
+require 'lm_rest'
+require 'colorize'
+
+def usage
+  puts "USAGE:\t" + $PROGRAM_NAME + ' account userid passwd datasource_name_or_glob'
+end
+
+if ARGV.length == 4
+  @account = ARGV[0]
+  @userid  = ARGV[1]
+  @passwd  = ARGV[2]
+  @lm = LMRest.new(@account, @userid, @passwd)
+else
+  usage
+  fail 'Bad arguments.'
+end
+
+def dp_type(datapoint)
+  datapoint.postProcessorMethod == 'expression' ? 'complex' : 'normal'
+end
+
+def test_datasource_name(datasource)
+  errors = []
+
+  # does the name contain whitespace?
+  errors.push('datasource name contains whitespace') if datasource.name =~ /\s+/
+
+  # does the name end in a trailing dash?
+  errors.push('datasource name has trailing dash') if datasource.name =~ /\-$/
+
+  # does the display name end in a trailing dash?
+  if datasource.displayName =~ /\-$/
+    errors.push('datasource display name has trailing dash')
+  end
+
+  errors
+end
+
+def test_datasource_description(datasource)
+  error = nil
+
+  # is the description size less than 10 characters in length?
+  if datasource.description.length < 10
+    error = 'datasource description is empty or sparse'
+  end
+
+  error
+end
+
+def test_datapoint_descriptions(datapoints)
+  errors = []
+
+  datapoints.each do |datapoint|
+    if datapoint.description.length < 10
+      errors.push("datapoint \"" + datapoint.name + "\" description is empty or sparse")
+    end
+  end
+
+  errors
+end
+
+def test_datapoint_alerts(datapoints)
+  errors = []
+
+  tokens = [
+    '##HOST##',
+    '##VALUE##',
+    '##DURATION##',
+    '##START##'
+  ]
+
+  datapoints.each do |datapoint|
+    # is there a datapoint alert trigger set, but no custom alert message
+    #
+    if (datapoint.alertExpr.size > 0) && (datapoint.alertBody == 0)
+      errors.push("datapoint \"" + datapoint.name +
+                  "\" has an alert threshold but no message")
+    end
+
+    # is there a custom alert message on this datapoint?
+    #
+    next unless datapoint.alertBody.size > 0
+    tokens.each do |token|
+      # is this token in the datasource definition?
+      #
+      unless datapoint.alertBody.include? token
+        errors.push("custom alert message on \"" + datapoint.name +
+                    "\" datpoint doesn't include token " + token)
+      end
+    end
+  end
+
+  errors
+end
+
+def test_datapoint_usage(datapoints, complex_datapoints, graphs, overview_graphs)
+  errors = []
+  datapoint_ok = []
+
+  puts 'Datapoints:'
+  # is an alert trigger set?
+  datapoints.each do |datapoint|
+    if datapoint.alertExpr.size > 0
+      puts ' - ' + dp_type(datapoint) + ' datapoint "' + datapoint.name + '" has alert threshold set'
+    else
+
+      # is this datapoint used in a complex datapoint?
+      complex_datapoints.each do |complex_datapoint|
+        next unless complex_datapoint.postProcessorParam.include? datapoint.name
+        puts(' - ' + dp_type(datapoint) + ' datapoint "' + datapoint.name +
+                       '" used in complex datapoint' + complex_datapoint.name)
+        datapoint_ok.push(datapoint.name)
+        break
+      end
+
+      # is this datapoint used in any graphs?
+      graphs.each do |graph|
+        graph.dataPoints.each do |graph_datapoint|
+          next unless datapoint.name == graph_datapoint['name']
+          puts(' - ' + dp_type(datapoint) + ' datapoint "' + datapoint.name +
+                           '" used in graph "' + graph.name + '" datapoint')
+          datapoint_ok.push(datapoint.name)
+          break
+        end
+      end
+
+      overview_graphs.each do |ograph|
+        ograph.dataPoints.each do |ograph_datapoint|
+          next unless datapoint.name == ograph_datapoint['name']
+          puts(' - ' + dp_type(datapoint) + ' datapoint "' + datapoint.name +
+                           '" used in overview graph "' + ograph.name + '" datapoint')
+          datapoint_ok.push(datapoint.name)
+          break
+        end
+      end
+
+      unless datapoint_ok.include? datapoint.name
+        errors.push("datapoint \"" + datapoint.name + "\" appears to be unused")
+      end
+    end
+  end
+
+  separator
+  errors
+end
+
+def test_graphs(graphs)
+  errors = []
+
+  puts 'Graphs:'
+
+  display_prios = {}
+  graphs.each do |graph|
+    puts ' - "' + graph.name + '" at display priority ' + graph.displayPrio.to_s
+    # does the y-axis label contain capital letters?
+    if graph.verticalLabel.match(/[A-Z]/)
+      errors.push('graph "' + graph.name +
+                  '" has uppercase letters in the y-axis definition (' +
+                  graph.verticalLabel + ')')
+    end
+
+    # has this graph priority already been used?
+    if display_prios.include? graph.displayPrio
+      errors.push('graph "' + graph.name + '" is assigned the same display priority (' +
+                  graph.displayPrio.to_s + ') as "' +
+                  display_prios[graph.displayPrio] + '"')
+    else
+      # no -- store this priority in a hash for further testing
+      display_prios[graph.displayPrio] = graph.name
+    end
+  end
+
+  separator
+  errors
+end
+
+def test_overview_graphs(overview_graphs)
+  errors = []
+
+  puts 'Overview Graphs:'
+
+  display_prios = {}
+  overview_graphs.each do |ograph|
+    puts ' - "' + ograph.name + '" at display priority ' + ograph.displayPrio.to_s
+    if ograph.verticalLabel.match(/[A-Z]/)
+      errors.push('overview graph "' + ograph.name +
+                  '" has uppercase letters in the y-axis definition (' +
+                  ograph.verticalLabel + ')')
+    end
+
+    if display_prios.include? ograph.displayPrio
+      errors.push('overview graph "' + ograph.name + '" is assigned the same display priority (' +
+                  ograph.displayPrio.to_s + ') as "' +
+                  display_prios[ograph.displayPrio] + '"')
+    else
+      display_prios[ograph.displayPrio] = ograph.name
+    end
+  end
+
+  separator
+  errors
+end
+
+def summarize(datasource, datapoints, graphs, overview_graphs)
+  datapoint_alert_count = 0
+  datapoints.each do |datapoint|
+    datapoint_alert_count += 1 if datapoint.alertExpr.size > 0
+  end
+
+  puts 'Summary:'
+
+  puts " - datasource name:\t#{datasource.name}"
+  puts " - display name:\t#{datasource.displayName}"
+  puts " - applies to:\t\t#{datasource.appliesTo}"
+  puts " - polling interval:\t#{datasource.collectInterval / 60}m"
+  puts " - multipoint instance:\t#{datasource.hasMultiInstances}"
+  puts " - datapoints:\t\t#{datasource.dataPoints.count}"
+  puts " - datapoint alerts:\t#{datapoint_alert_count}"
+  puts " - graphs:\t\t#{graphs.count}"
+  puts " - overview graphs:\t#{overview_graphs.count}"
+
+  separator
+end
+
+def propose_fixes(errors)
+  puts 'Proposed Fixes:'
+
+  errors.flatten.each do |error|
+    puts " * #{error}".colorize(:red)
+  end
+end
+
+def separator
+  puts '============================='
+end
+
+@datasources = @lm.get_datasources(filter: "name:#{ARGV[3]}")
+
+@datasources.each do |datasource|
+  errors = []
+  datapoints = @lm.get_datapoints(datasource.id)
+  complex_datapoints = datapoints.select { |dp| dp.postProcessorMethod == 'expression' }
+  graphs = @lm.get_graphs(datasource.id)
+  overview_graphs = @lm.get_overview_graphs(datasource.id)
+
+  summarize(datasource, datapoints, graphs, overview_graphs)
+  errors << test_datasource_name(datasource)
+  errors << test_datapoint_descriptions(datapoints)
+  errors << test_datapoint_alerts(datapoints)
+  errors << test_datapoint_usage(datapoints, complex_datapoints, graphs, overview_graphs)
+  errors << test_graphs(graphs)
+  errors << test_overview_graphs(overview_graphs)
+  propose_fixes(errors)
+
+  separator
+end

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/lib/lm_rest.rb

@@ -0,0 +1,7 @@
+require 'lm_rest/version'
+require 'lm_rest/api_client'
+require 'lm_rest/resource'
+require 'lm_rest/request_params'
+
+module LMRest
+end

data/lib/lm_rest/api_client.rb

@@ -0,0 +1,326 @@
+require 'date'
+require 'base64'
+require 'openssl'
+require 'rest-client'
+require 'json'
+require 'lm_rest/resource'
+require 'lm_rest/request_params'
+
+module LMRest
+  class APIClient
+    include RequestParams
+
+    ITEMS_SIZE_LIMIT = 1000
+    ITEMS_SIZE_DEFAULT = 50
+
+    BASE_URL_PREFIX = 'https://'
+    BASE_URL_SUFFIX = '.logicmonitor.com/santaba/rest'
+
+    attr_reader :company, :api_url, :access_id
+
+    def initialize(company = nil, access_id =  nil, access_key = nil)
+      APIClient.setup
+      @company     = company
+      @access_id   = access_id
+      @access_key  = access_key
+      @api_url     = BASE_URL_PREFIX + company + BASE_URL_SUFFIX
+    end
+
+    def uri_to_resource_uri(uri)
+      # Split the URL down to the resource
+      #
+      # Here's an example of the process:
+      # /setting/datasources/1/graphs?key-value&
+      # /setting/datasources/1/graphs
+      # /setting/datasources/
+      # /setting/datasources
+      #
+      uri.split("?")[0].split("/").join("/")
+    end
+
+    def snakerize(string)
+      string.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    def sign(method, uri, data = nil)
+
+      resource_uri = uri_to_resource_uri(uri)
+
+      time = DateTime.now.strftime('%Q')
+
+      http_method = method.to_s.upcase
+
+      if data.nil? || data.empty?
+        data = ''
+      else
+        data = data.to_json.to_s
+      end
+
+      message =  "#{http_method}#{time}#{data}#{resource_uri}"
+
+      signature = Base64.strict_encode64(
+        OpenSSL::HMAC.hexdigest(
+          OpenSSL::Digest.new('sha256'),
+          access_key,
+          message
+        )
+      )
+
+      "LMv1 #{access_id}:#{signature}:#{time}"
+    end
+
+    def request(method, uri, params={})
+      headers = {}
+      headers['Authorization'] = sign(method, uri, params)
+      headers['Content-Type'] = 'application/json'
+      headers['Accept'] = 'application/json, text/javascript'
+      headers['X-version'] = '2'
+
+      url = api_url + uri
+      #puts "URL: " + url
+      #puts headers
+
+      json_params = params.to_json
+
+      case method
+      when :get
+        response = RestClient.get(url, headers)
+      when :post
+        response = RestClient.post(url, json_params, headers)
+      when :put
+        response = RestClient.put(url, json_params, headers)
+      when :delete
+        response = RestClient.delete(url, headers: headers)
+      end
+
+      if response.code != 200
+        puts response.code.to_s + ":" + response.body.to_s
+        raise
+      end
+
+
+      JSON.parse(response.body)
+    end
+
+    # Handles making multiple requests to the API if pagination is necessary.
+    # Pagination is transparent, and simplifies requests that result in more
+    # than ITEMS_SIZE_LIMIT being returned.
+    #
+    # If you need to walk through resources page-by-page manullay, use the
+    # request() method with the 'offset' and 'size' params
+    #
+    def paginate(uri, params)
+
+      # Hooray for pagination logic!
+      if (params[:size] == 0 || params[:size].nil? || params[:size] > ITEMS_SIZE_LIMIT)
+        # save user-entered size in a param for use later
+        user_size = params[:size]
+
+        # set our size param to the max
+        params[:size] = ITEMS_SIZE_LIMIT
+
+        # Set our offset to grab the first page of results 
+        params[:offset] ||= 0
+
+        # make the initial request
+        body = request(:get, uri.call(params), nil)
+
+        # pull the actual items out of the request body and into our
+        # item_collector while we build up the items list
+        item_collector = body['items']
+
+        # The API sends the total number of objects back in the first request.
+        # We need this to determine how many more pages to pull
+        total = body['total']
+
+        # If user didn't pass size param, set it to total
+        # This just means you'll get all items if not specifying a size
+        user_size ||= total
+
+        # If the user passed a size larger than what's available, set it to
+        # total to retrieve all items
+        if user_size > total
+          user_size = total
+        end
+
+        # calculate the remaining number of items (after first request)
+        # then use that to figure out how many more times we need to call
+        # request() to get all the items, then do it
+        pages_remaining = ((user_size - ITEMS_SIZE_LIMIT).to_f/ITEMS_SIZE_LIMIT).ceil
+
+        pages_remaining.times do |page|
+
+          # Increment the offset by the limit to get the next page
+          params[:offset] += ITEMS_SIZE_LIMIT
+
+          # if this is the last page, get the remainder
+          if page == pages_remaining - 1
+            params[:size]  = user_size%ITEMS_SIZE_LIMIT
+          else
+            # else, get a whole page
+            params[:size] = ITEMS_SIZE_LIMIT
+          end
+
+          # make a subsequent request with modified params
+          body = request(:get, uri.call(params), nil)
+
+          # add these items to our item_collector
+          item_collector += body['items']
+        end
+
+        body['items'] = item_collector
+        body
+      else
+        # No pagination required, just request the page
+        request(:get, uri.call(params), nil)
+      end
+    end
+
+    def self.process_paths
+      resource_uri = attributes['url']
+      @@api_json[paths].keys.each do |path|
+
+        path.keys.each do |action|
+          case action
+          when 'get'
+
+            uri = lambda { |params| "#{resource_uri}#{RequestParams.parameterize(params)}"}
+            method_name = snakerize(@@api_json['paths'][path][action][operationId])
+
+            unless plural.nil?
+              # Define a method to fetch multiple resources with optional params
+              define_method("get_#{plural}") do |params = {}|
+                Resource.parse paginate(uri, params)
+              end
+            end
+
+            # Define a method to get one resource by it's id number, with optional
+            # params, thought now that I think about it I'm not sure why you'd pass
+            # params when grabbing just one resource.
+
+            # Some resources are Singletons
+            unless singular.nil?
+              define_method("get_#{singular}") do |*args|
+                case args.size
+                when 0
+                  Resource.parse request(:get, "#{resource_uri}", nil)
+                when 1
+                  Resource.parse request(:get, "#{resource_uri}/#{args[0]}", nil)
+                when 2
+                  Resource.parse request(:get, "#{resource_uri}/#{args[0]}#{RequestParams.parameterize(args[1])}", nil)
+                else
+                  raise ArgumentError.new("wrong number for arguments (#{args.count} for 1..2)")
+                end
+              end
+            end
+
+          when 'add'
+
+            # Define a method to add a new resource to the account
+            define_method("add_#{singular}") do |properties|
+              if properties.class == LMRest::Resource
+                Resource.parse request(:post, "#{resource_uri}", properties.to_h)
+              else
+                Resource.parse request(:post, "#{resource_uri}", properties)
+              end
+            end
+
+          when 'update'
+
+            # Define a method to update a resource
+            define_method("update_#{singular}") do |id, properties = {}|
+              if id.class == LMRest::Resource
+                Resource.parse request(:put, "#{resource_uri}/#{id.id}", id.to_h)
+              else
+                Resource.parse request(:put, "#{resource_uri}/#{id}", properties)
+              end
+            end
+
+          when 'delete'
+
+            # Define a method to delete the resource
+            define_method("delete_#{singular}") do |id|
+              if id.class == LMRest::Resource
+                id = id.id
+                Resource.parse request(:delete, "#{resource_uri}/#{id}", nil)
+              else
+                Resource.parse request(:delete, "#{resource_uri}/#{id}", nil)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.define_child_methods(resource_type, attributes)
+      parent_singular = attributes['method_names']['singular']
+      parent_plural = attributes['method_names']['plural']
+      parent_resource_uri = attributes['url']
+      parent_id = attributes['parent_id_key']
+      children = attributes['children']
+
+      children.each do |child_name|
+        if @@api_json[child_name]
+          child = @@api_json[child_name]
+        else
+          raise "Child resource " + child_name + " not defined."
+        end
+
+        child_singular = child['method_names']['singular']
+        child_plural = child['method_names']['plural']
+        child_resource_uri = attributes['url'].split("/").last
+
+        child['actions'].each do |action|
+          case action
+          when 'get'
+
+            define_method("get_#{parent_singular}_#{child_plural}") do |id, params = {}, &block|
+              uri = lambda { |params| "#{parent_resource_uri}/#{id}/#{child['method_names']['plural']}#{RequestParams.parameterize(params)}" }
+              Resource.parse paginate(uri, params)
+            end
+
+          when 'add'
+          when 'update'
+          when 'delete'
+          end
+        end
+      end
+    end
+
+    # Define methods based on the JSON structure
+    def self.setup
+      @@api_definition_path = File.expand_path(File.join(File.dirname(__FILE__), "../../api.json"))
+      @@api_json = JSON.parse(File.read(@@api_definition_path))
+      @@api_json.each do |resource_type, attributes|
+        define_action_methods(resource_type, attributes) if attributes['actions']
+        define_child_methods(resource_type, attributes) if attributes['children']
+      end
+    end
+
+    # Ack a down collector, pass the ID and a comment
+    def ack_collector_down(id, comment)
+      if id.class == LMRest::Resource
+        Resource.parse request(:post, "/setting/collectors/#{id.id}/ackdown", {comment: comment})
+      else
+        Resource.parse request(:post, "/setting/collectors/#{id}/ackdown", {comment: comment})
+      end
+    end
+
+    # run a report
+    def run_report(id, type = "generateReport")
+      if id.class == LMRest::Resource
+        Resource.parse request(:post, "/functions", {reportId: id.id, type: type})
+      else
+        Resource.parse request(:post, "/functions", {reportId: id, type: type})
+      end
+    end
+
+    private
+
+    attr_accessor :access_key
+  end
+end