lm_rest 1.0.6 → 1.0.7

data/bin/ds_checker.rb

@@ -1,261 +1,278 @@
 #!/usr/bin/env ruby
-#
-#
-# Based on a script written originally by Matt Dunham
-#
+
 require 'lm_rest'
-require 'colorize'
+
+STANDARD_GRAPH_NOTE = 'Standard datasource graph checks are skipped because the current LogicMonitor v3 Swagger surface only exposes datasource overview graph endpoints.'.freeze
 
 def usage
-  puts "USAGE:\t" + $PROGRAM_NAME + ' account userid passwd datasource_name_or_glob'
+  puts "USAGE:\t#{$PROGRAM_NAME} account access_id access_key datasource_name_or_glob"
+end
+
+abort('Bad arguments.') unless ARGV.length == 4
+
+@account, @access_id, @access_key, @datasource_filter = ARGV
+@lm = LMRest::APIClient.new(@account, @access_id, @access_key)
+@standard_graph_note_printed = false
+
+def wrap_resources(items)
+  Array(items).map { |item| item.is_a?(LMRest::Resource) ? item : LMRest::Resource.new(item) }
+end
+
+def resource_value(resource, *keys)
+  keys.each do |key|
+    return resource.public_send(key) if resource.respond_to?(key)
+    return resource[key] if resource.respond_to?(:key?) && resource.key?(key)
+    return resource[key.to_s] if resource.is_a?(Hash) && resource.key?(key.to_s)
+    return resource[key] if resource.is_a?(Hash) && resource.key?(key)
+  end
+
+  nil
 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.'
+def fetch_datasource_details(datasource_id)
+  @lm.get_datasource(
+    datasource_id,
+    fields: 'name,displayName,description,appliesTo,collectInterval,hasMultiInstances,dataPoints'
+  )
+end
+
+def fetch_datapoints(datasource)
+  wrap_resources(resource_value(datasource, :dataPoints))
+end
+
+def fetch_overview_graphs(datasource_id)
+  wrap_resources(@lm.get_data_source_overview_graph_list(datasource_id))
+end
+
+def fetch_standard_graphs(_datasource_id)
+  return [] if @standard_graph_note_printed
+
+  puts STANDARD_GRAPH_NOTE
+  @standard_graph_note_printed = true
+  []
 end
 
 def dp_type(datapoint)
-  datapoint.postProcessorMethod == 'expression' ? 'complex' : 'normal'
+  resource_value(datapoint, :postProcessorMethod).to_s == 'expression' ? 'complex' : 'normal'
 end
 
 def test_datasource_name(datasource)
   errors = []
+  name = resource_value(datasource, :name).to_s
+  display_name = resource_value(datasource, :displayName).to_s
 
-  # 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 << 'datasource name contains whitespace' if name.match?(/\s+/)
+  errors << 'datasource name has trailing dash' if name.end_with?('-')
+  errors << 'datasource display name has trailing dash' if display_name.end_with?('-')
 
   errors
 end
 
 def test_datasource_description(datasource)
-  error = nil
+  description = resource_value(datasource, :description).to_s.strip
+  return nil unless description.length < 10
 
-  # is the description size less than 10 characters in length?
-  if datasource.description.length < 10
-    error = 'datasource description is empty or sparse'
-  end
-
-  error
+  'datasource description is empty or sparse'
 end
 
 def test_datapoint_descriptions(datapoints)
+  datapoints.filter_map do |datapoint|
+    description = resource_value(datapoint, :description).to_s.strip
+    next unless description.length < 10
+
+    %(datapoint "#{resource_value(datapoint, :name)}" description is empty or sparse)
+  end
+end
+
+def test_datapoint_alerts(datapoints)
   errors = []
+  tokens = %w[##HOST## ##VALUE## ##DURATION## ##START##]
 
   datapoints.each do |datapoint|
-    if datapoint.description.length < 10
-      errors.push("datapoint \"" + datapoint.name + "\" description is empty or sparse")
-    end
+    check_alert_threshold(datapoint, errors)
+    check_custom_alert_message(datapoint, tokens, errors)
   end
 
   errors
 end
 
-def test_datapoint_alerts(datapoints)
-  errors = []
+def check_alert_threshold(datapoint, errors)
+  alert_expr = resource_value(datapoint, :alertExpr).to_s
+  alert_body = resource_value(datapoint, :alertBody).to_s
+  return if alert_expr.empty? || !alert_body.empty?
 
-  tokens = [
-    '##HOST##',
-    '##VALUE##',
-    '##DURATION##',
-    '##START##'
-  ]
+  errors << %(datapoint "#{resource_value(datapoint, :name)}" has an alert threshold but no message)
+end
 
-  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
+def check_custom_alert_message(datapoint, tokens, errors)
+  alert_body = resource_value(datapoint, :alertBody).to_s
+  return if alert_body.empty?
 
-    # 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
+  tokens.each do |token|
+    next if alert_body.include?(token)
 
-  errors
+    errors << %(custom alert message on "#{resource_value(datapoint, :name)}" datapoint doesn't include token #{token})
+  end
 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
+    if !resource_value(datapoint, :alertExpr).to_s.empty?
+      puts %( - #{dp_type(datapoint)} datapoint "#{resource_value(datapoint, :name)}" has alert threshold set)
+      next
     end
+
+    check_complex_datapoints(datapoint, complex_datapoints, datapoint_ok)
+    track_graph_usage(datapoint, graphs, datapoint_ok, 'graph')
+    track_graph_usage(datapoint, overview_graphs, datapoint_ok, 'overview graph')
   end
 
-  separator
-  errors
+  check_datapoints(datapoints, datapoint_ok)
 end
 
-def test_graphs(graphs)
-  errors = []
+def check_complex_datapoints(datapoint, complex_datapoints, datapoint_ok)
+  complex_datapoints.each do |complex_datapoint|
+    next unless resource_value(complex_datapoint, :postProcessorParam).to_s.include?(resource_value(datapoint, :name).to_s)
 
-  puts 'Graphs:'
+    puts %( - #{dp_type(datapoint)} datapoint "#{resource_value(datapoint, :name)}" used in complex datapoint #{resource_value(complex_datapoint, :name)})
+    datapoint_ok << resource_value(datapoint, :name)
+    break
+  end
+end
+
+def track_graph_usage(datapoint, graphs, datapoint_ok, graph_type)
+  datapoint_name = resource_value(datapoint, :name).to_s
 
-  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
+    extract_graph_datapoints(graph).each do |graph_datapoint|
+      next unless datapoint_name == graph_datapoint_name(graph_datapoint)
 
-    # 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
+      puts %( - #{dp_type(datapoint)} datapoint "#{datapoint_name}" used in #{graph_type} "#{resource_value(graph, :name)}")
+      datapoint_ok << datapoint_name
+      break
     end
   end
+end
 
+def extract_graph_datapoints(graph)
+  Array(resource_value(graph, :dataPoints, :lines, :graphDataPoints))
+end
+
+def graph_datapoint_name(graph_datapoint)
+  if graph_datapoint.is_a?(LMRest::Resource)
+    resource_value(graph_datapoint, :name, :dataPointName)
+  elsif graph_datapoint.is_a?(Hash)
+    graph_datapoint['name'] || graph_datapoint[:name] || graph_datapoint['dataPointName'] || graph_datapoint[:dataPointName]
+  else
+    nil
+  end.to_s
+end
+
+def test_graphs(graphs)
+  puts 'Graphs:'
+  errors = check_graph_definitions(graphs, 'graph')
   separator
   errors
 end
 
 def test_overview_graphs(overview_graphs)
-  errors = []
-
   puts 'Overview Graphs:'
+  errors = check_graph_definitions(overview_graphs, 'overview graph')
+  separator
+  errors
+end
+
+def check_datapoints(datapoints, used_datapoints)
+  used_datapoints = used_datapoints.compact.uniq
+
+  datapoints.filter_map do |datapoint|
+    next if used_datapoints.include?(resource_value(datapoint, :name))
+
+    %(datapoint "#{resource_value(datapoint, :name)}" appears to be unused)
+  end
+end
 
+def check_graph_definitions(graphs, graph_type)
+  errors = []
   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 + ')')
+
+  graphs.each do |graph|
+    name = resource_value(graph, :name).to_s
+    display_prio = resource_value(graph, :displayPrio, :displayPriority)
+    vertical_label = resource_value(graph, :verticalLabel, :yAxisLabel).to_s
+
+    puts %( - "#{name}" at display priority #{display_prio})
+    if vertical_label.match?(/[A-Z]/)
+      errors << %(#{graph_type} "#{name}" has uppercase letters in the y-axis definition (#{vertical_label}))
     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
+    if !display_prio.nil? && display_prios.key?(display_prio)
+      errors << %(#{graph_type} "#{name}" is assigned the same display priority (#{display_prio}) as "#{display_prios[display_prio]}")
+    elsif !display_prio.nil?
+      display_prios[display_prio] = 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
+  datapoint_alert_count = datapoints.count { |datapoint| !resource_value(datapoint, :alertExpr).to_s.empty? }
 
   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 " - datasource name:\t#{resource_value(datasource, :name)}"
+  puts " - display name:\t#{resource_value(datasource, :displayName)}"
+  puts " - description:\t\t#{resource_value(datasource, :description)}"
+  puts " - applies to:\t\t#{resource_value(datasource, :appliesTo)}"
+  puts " - polling interval:\t#{resource_value(datasource, :collectInterval).to_i / 60}m"
+  puts " - multipoint instance:\t#{resource_value(datasource, :hasMultiInstances)}"
+  puts " - datapoints:\t\t#{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)
+  flattened = errors.flatten.compact
+  if flattened.empty?
+    puts ' * none'
+    return
+  end
+
+  flattened.each do |error|
+    puts " * #{error}"
   end
 end
 
 def separator
-  puts '============================='
+  puts '-' * 40
 end
 
-@datasources = @lm.get_datasources(filter: "name:#{ARGV[3]}")
+datasources = @lm.get_datasources(filter: %(name:"#{@datasource_filter}"))
+abort("No datasources matched #{@datasource_filter.inspect}") if datasources.empty?
 
-@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)
+datasources.each do |datasource|
+  datasource = fetch_datasource_details(datasource.id)
+  datapoints = fetch_datapoints(datasource)
+  complex_datapoints = datapoints.select { |dp| dp_type(dp) == 'complex' }
+  graphs = fetch_standard_graphs(datasource.id)
+  overview_graphs = fetch_overview_graphs(datasource.id)
 
+  errors = []
   summarize(datasource, datapoints, graphs, overview_graphs)
   errors << test_datasource_name(datasource)
+  errors << test_datasource_description(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/graphgrab.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+#
+#
+#
+=begin require 'lm_rest'
+
+def usage
+  puts "USAGE:\t" + $PROGRAM_NAME + ' account userid passwd'
+end
+
+if ARGV.length == 3
+  @account = ARGV[0]
+  @userid  = ARGV[1]
+  @passwd  = ARGV[2]
+  @lm = LMRest.new(@account, @userid, @passwd)
+else
+  usage
+  fail 'Bad arguments.'
+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 =end