dropsonde 0.0.5 → 0.0.6

data/lib/dropsonde/metrics/platforms.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# platforms plugin
 class Dropsonde::Metrics::Platforms
   def self.initialize_platforms
     # require any libraries needed here -- no need to load puppet; it's already initialized
@@ -5,11 +8,11 @@ class Dropsonde::Metrics::Platforms
   end
 
   def self.description
-    <<~EOF
+    <<~DESCRIPTION
       This group of metrics generates usage patterns by platform.
       Currently implemented is a list of classes, the platforms
       they are declared on, and a count of each combination.
-    EOF
+    DESCRIPTION
   end
 
   def self.schema
@@ -19,29 +22,29 @@ class Dropsonde::Metrics::Platforms
       {
         "fields": [
           {
-            "description": "The class name name",
-            "mode": "NULLABLE",
-            "name": "name",
-            "type": "STRING"
+            "description": 'The class name name',
+            "mode": 'NULLABLE',
+            "name": 'name',
+            "type": 'STRING',
           },
           {
-            "description": "The osfamily of the node the class is declared on",
-            "mode": "NULLABLE",
-            "name": "platform",
-            "type": "STRING"
+            "description": 'The osfamily of the node the class is declared on',
+            "mode": 'NULLABLE',
+            "name": 'platform',
+            "type": 'STRING',
           },
           {
-            "description": "The number of time this combination is declared",
-            "mode": "NULLABLE",
-            "name": "count",
-            "type": "INTEGER"
+            "description": 'The number of time this combination is declared',
+            "mode": 'NULLABLE',
+            "name": 'count',
+            "type": 'INTEGER',
           },
         ],
         "description": "List of all classes in the infrastructure and platforms they're declared on.",
-        "mode": "REPEATED",
-        "name": "class_platforms",
-        "type": "RECORD"
-      }
+        "mode": 'REPEATED',
+        "name": 'class_platforms',
+        "type": 'RECORD',
+      },
     ]
   end
 
@@ -49,44 +52,43 @@ class Dropsonde::Metrics::Platforms
     # run just before generating this metric
   end
 
-  def self.run
+  def self.run(puppetdb_session = nil)
     # skip this metric if we don't have an active PuppetDB connection
-    return unless Dropsonde.puppetDB
+    return unless puppetdb_session
 
-    classes = Dropsonde.puppetDB.request( '', 'resources[certname, title] { type = "Class" }').data
-    facts   = Dropsonde.puppetDB.request( '', 'facts[certname, value] { name = "osfamily" }').data
+    classes = puppetdb_session.puppet_db.request('', 'resources[certname, title] { type = "Class" }').data
+    facts   = puppetdb_session.puppet_db.request('', 'facts[certname, value] { name = "osfamily" }').data
 
     # All public Forge modules that are installed.
-    modules = Puppet.lookup(:environments).list.map {|env|
-        env.modules.select {|mod|
-            mod.forge_module?
-        }.map {|fmod|
-            fmod.name
-        }}.flatten.uniq
-
-    data = classes.map {|item|
-        # filter out any that don't come from public Forge modules
-        mod = item['title'].split('::').first.downcase
-        next unless modules.include? mod
-
-        item['platform'] = facts.find {|fact|
-            fact['certname'] == item['certname']
-        }['value']
+    modules = Puppet.lookup(:environments).list.map { |env|
+      env.modules.select { |mod| mod.forge_module? }.map do |fmod|
+        fmod.name
+      end
+    }.flatten.uniq
 
-        {
-            :name     => item['title'],
-            :platform => item['platform'],
-        }
+    data = classes.map { |item|
+      # filter out any that don't come from public Forge modules
+      mod = item['title'].split('::').first.downcase
+      next unless modules.include? mod
+
+      item['platform'] = facts.find { |fact|
+        fact['certname'] == item['certname']
+      }['value']
+
+      {
+        name: item['title'],
+        platform: item['platform'],
+      }
     }.compact
 
-    data.each {|item|
-        item['count'] = data.select {|i|
-            i[:name] == item[:name] and i[:platform] == item[:platform]
-        }.count
-    }
+    data.each do |item|
+      item[:count] = data.select { |i|
+        i[:name] == item[:name] and i[:platform] == item[:platform]
+      }.count
+    end
 
     [
-      :class_platforms => data,
+      class_platforms: data,
     ]
   end
 
@@ -95,25 +97,26 @@ class Dropsonde::Metrics::Platforms
     # make it easier to write data aggregation queries without access to the
     # actual private data that users have submitted.
 
-    platforms = ['RedHat', 'Debian', 'Windows', 'Suse', 'FreeBSD', 'Darwin', 'Archlinux', 'AIX']
+    platforms = %w[RedHat Debian Windows Suse FreeBSD Darwin Archlinux AIX]
     classes   = ['', '::Config', '::Service', '::Server', '::Client', '::Packages']
 
-    data = Dropsonde::Cache.modules
-            .sample(rand(35))
-            .map do |item|
-                name = item.split('-').last.capitalize + classes.sample
+    dropsonde_cache = Dropsonde::Cache.new('foo', 7, true)
+    data = dropsonde_cache.modules
+                          .sample(rand(35))
+                          .map { |item|
+      name = item.split('-').last.capitalize + classes.sample
 
-                rand(5).times.map do
-                    {
-                        :name     => name,
-                        :platform => platforms.sample,
-                        :count    => rand(1000),
-                    }
-                end
-            end.flatten
+      rand(5).times.map do
+        {
+          name: name,
+          platform: platforms.sample,
+          count: rand(1000),
+        }
+      end
+    }.flatten
 
     [
-      :class_platforms => data.uniq,
+      class_platforms: data.uniq,
     ]
   end
 

data/lib/dropsonde/metrics/puppetfiles.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# puppetfiles plugin
 class Dropsonde::Metrics::Puppetfiles
   def self.initialize_puppetfiles
     # require any libraries needed here -- no need to load puppet; it's already initialized
@@ -6,10 +9,10 @@ class Dropsonde::Metrics::Puppetfiles
   end
 
   def self.description
-    <<~EOF
+    <<~DESCRIPTION
       This generates interesting stats about Puppetfiles used in your environments,
       including whether your Puppetfiles have Ruby code in them.
-    EOF
+    DESCRIPTION
   end
 
   def self.schema
@@ -19,23 +22,23 @@ class Dropsonde::Metrics::Puppetfiles
       {
         "fields": [
           {
-            "description": "The method name",
-            "mode": "NULLABLE",
-            "name": "name",
-            "type": "STRING"
+            "description": 'The method name',
+            "mode": 'NULLABLE',
+            "name": 'name',
+            "type": 'STRING',
           },
           {
-            "description": "How many times is it used",
-            "mode": "NULLABLE",
-            "name": "count",
-            "type": "INTEGER"
-          }
+            "description": 'How many times is it used',
+            "mode": 'NULLABLE',
+            "name": 'count',
+            "type": 'INTEGER',
+          },
         ],
-        "description": "Ruby methods used in Puppetfiles.",
-        "mode": "REPEATED",
-        "name": "puppetfile_ruby_methods",
-        "type": "RECORD"
-      }
+        "description": 'Ruby methods used in Puppetfiles.',
+        "mode": 'REPEATED',
+        "name": 'puppetfile_ruby_methods',
+        "type": 'RECORD',
+      },
     ]
   end
 
@@ -43,30 +46,30 @@ class Dropsonde::Metrics::Puppetfiles
     # run just before generating this metric
   end
 
-  def self.run
-    methods = Dir.entries(Puppet.settings[:environmentpath]).map do |entry|
+  def self.run(_puppetdb_session = nil)
+    methods = Dir.entries(Puppet.settings[:environmentpath]).map { |entry|
       puppetfile = File.join(Puppet.settings[:environmentpath], entry, 'Puppetfile')
 
       next if entry.start_with? '.'
       next unless File.file? puppetfile
 
       tokens  = Ripper.sexp(File.read(puppetfile)).flatten
-      indices = tokens.map.with_index {|a, i| a == :command ? i : nil}.compact
+      indices = tokens.map.with_index { |a, i| a == :command ? i : nil }.compact
 
-      indices.map {|i| tokens[i+2] }
-    end.flatten.compact
+      indices.map { |i| tokens[i + 2] }
+    }.flatten.compact
 
-    methods.reject! {|name| ['mod', 'forge', 'moduledir'].include? name }
+    methods.reject! { |name| %w[mod forge moduledir].include? name }
 
     methods = methods.uniq.map do |name|
       {
-        :name  => name,
-        :count => methods.count(name),
+        name: name,
+        count: methods.count(name),
       }
     end
 
     [
-      { :puppetfile_ruby_methods => methods },
+      { puppetfile_ruby_methods: methods },
     ]
   end
 
@@ -75,13 +78,13 @@ class Dropsonde::Metrics::Puppetfiles
     # make it easier to write data aggregation queries without access to the
     # actual private data that users have submitted.
     [
-      :puppetfile_ruby_methods => [
-        {:name => 'require', :count => rand(200)},
-        {:name => 'each',    :count => rand(200)},
-        {:name => 'puts',    :count => rand(200)},
-        {:name => 'select',  :count => rand(200)},
-        {:name => 'reject',  :count => rand(200)},
-        {:name => 'read',    :count => rand(200)},
+      puppetfile_ruby_methods: [
+        { name: 'require', count: rand(200) },
+        { name: 'each',    count: rand(200) },
+        { name: 'puts',    count: rand(200) },
+        { name: 'select',  count: rand(200) },
+        { name: 'reject',  count: rand(200) },
+        { name: 'read',    count: rand(200) },
       ].shuffle,
     ]
   end

data/lib/dropsonde/metrics.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require 'little-plugger'
+require 'securerandom'
 
+# metrics class
 class Dropsonde::Metrics
-  extend LittlePlugger( :path => 'dropsonde/metrics', :module => Dropsonde::Metrics)
+  extend LittlePlugger(path: 'dropsonde/metrics', module: Dropsonde::Metrics)
 
   def initialize
     if Dropsonde.settings[:enable]
@@ -17,76 +21,81 @@ class Dropsonde::Metrics
   def siteid
     return @siteid if @siteid
 
-    sha2 = Digest::SHA512.new
-    sha2.update Puppet.settings[:certname]
-    sha2.update Puppet.settings[:cacert]
-    sha2.update Dropsonde.settings[:seed] if Dropsonde.settings[:seed]
-    @siteid = sha2.hexdigest
+    @siteid = Dropsonde.settings[:siteid]
+
+    unless @siteid
+      sha2 = Digest::SHA512.new
+      sha2.update Puppet.settings[:certname]
+      sha2.update Puppet.settings[:cacert]
+      sha2.update Dropsonde.settings[:seed] if Dropsonde.settings[:seed]
+      @siteid = sha2.hexdigest
+    end
+
     @siteid
   end
 
   def list
-    str  = "                    Loaded telemetry plugins\n"
-    str << "                 ===============================\n\n"
+    str = "                    Loaded telemetry plugins\n"
+    str += "                 ===============================\n\n"
     Dropsonde::Metrics.plugins.each do |name, plugin|
-      str << name.to_s
-      str << "\n--------\n"
-      str << plugin.description.strip
-      str << "\n\n"
+      str += name.to_s
+      str += "\n--------\n"
+      str += plugin.description.strip
+      str += "\n\n"
     end
     if Dropsonde.settings[:disable]
-      str << "Disabled plugins:\n"
-      str << "  #{Dropsonde.settings[:disable].join(', ')}"
+      str += "Disabled plugins:\n"
+      str += "  #{Dropsonde.settings[:disable].join(', ')}"
     end
     str
   end
 
   def schema
     schema = skeleton_schema
-    Dropsonde::Metrics.plugins.each do |name, plugin|
+    Dropsonde::Metrics.plugins.each do |_name, plugin|
       schema.concat(sanity_check_schema(plugin))
     end
     check_for_duplicates(schema)
     schema
   end
 
-  def preview
-    str  = "                      Puppet Telemetry Report Preview\n"
-    str << "                      ===============================\n\n"
-    Dropsonde::Metrics.plugins.each do |name, plugin|
+  def preview(puppetdb_session = nil)
+    str = "                      Puppet Telemetry Report Preview\n"
+    str += "                      ===============================\n\n"
+    Dropsonde::Metrics.plugins.each do |_name, plugin|
       schema = plugin.schema
 
       plugin.setup if plugin.respond_to? :setup
-      data = sanity_check_data(plugin, plugin.run)
+      data = sanity_check_data(plugin, plugin.run(puppetdb_session))
       plugin.cleanup if plugin.respond_to? :cleanup
 
-      str << plugin.name+"\n"
-      str << "-------------------------------\n"
-      str << plugin.description
+      str += "#{plugin.name}\n"
+      str += "-------------------------------\n"
+      str += plugin.description
       data.each do |row|
         key    = row.keys.first
         values = row.values.flatten
 
-        desc = schema.find {|item| item[:name].to_sym == key.to_sym}[:description]
-        str << "- #{key}: #{desc}\n"
+        desc = schema.find { |item| item[:name].to_sym == key.to_sym }[:description]
+        str += "- #{key}: #{desc}\n"
         values.each do |item|
-          str << "    #{item}\n"
+          str += "    #{item}\n"
         end
       end
-      str << "\n\n"
+      str += "\n\n"
     end
-    str << "Site ID:\n"
-    str << siteid
+    str += "Site ID:\n"
+    str += siteid
     str
   end
 
-  def report
+  def report(puppetdb_session = nil)
     snapshots = {}
-    Dropsonde::Metrics.plugins.each do |name, plugin|
+    Dropsonde::Metrics.plugins.each do |_name, plugin|
       plugin.setup
-      sanity_check_data(plugin, plugin.run).each do |row|
+      sanity_check_data(plugin, plugin.run(puppetdb_session)).each do |row|
         snapshots[row.keys.first] = {
-          'value'     => row.values.first,
+          'value' => row.values.first,
           'timestamp' => Time.now.iso8601,
         }
       end
@@ -106,7 +115,7 @@ class Dropsonde::Metrics
     results[:ip]         = IPAddr.new(rand(2**32), Socket::AF_INET)
     results.delete(:'self-service-analytics')
 
-    Dropsonde::Metrics.plugins.each do |name, plugin|
+    Dropsonde::Metrics.plugins.each do |_name, plugin|
       sanity_check_data(plugin, plugin.example).each do |row|
         results.merge!(row)
       end
@@ -121,8 +130,8 @@ class Dropsonde::Metrics
     # This allows plugin authors to easily skip metrics with no results
     return [] if data.nil?
 
-    keys_data   = data.map {|item| item.keys }.flatten.map(&:to_s)
-    keys_schema = plugin.schema.map {|item| item[:name] }
+    keys_data   = data.map { |item| item.keys }.flatten.map(&:to_s)
+    keys_schema = plugin.schema.map { |item| item[:name] }
 
     disallowed = (keys_data - keys_schema)
 
@@ -134,16 +143,16 @@ class Dropsonde::Metrics
   def sanity_check_schema(plugin)
     schema = plugin.schema
 
-    if schema.class != Array or schema.find {|item| item.class != Hash}
+    if (schema.class != Array) || schema.find { |item| item.class != Hash }
       raise "The #{plugin.name} plugin schema is not an array of hashes"
     end
 
     error = ''
     [:name, :type, :description].each do |field|
-      count = schema.reject {|item| item[field] }.count
-      next if count == 0
+      count = schema.reject { |item| item[field] }.count
+      next if count.zero?
 
-      error << "The #{plugin.name} plugin schema has #{count} missing #{field}s\n"
+      error += "The #{plugin.name} plugin schema has #{count} missing #{field}s\n"
     end
     raise error unless error.empty?
 
@@ -151,8 +160,8 @@ class Dropsonde::Metrics
   end
 
   def check_for_duplicates(schema)
-    keys  = schema.map {|col| col[:name] }
-    dupes = keys.select{ |e| keys.count(e) > 1 }.uniq
+    keys  = schema.map { |col| col[:name] }
+    dupes = keys.select { |e| keys.count(e) > 1 }.uniq
 
     raise "The schema defines duplicate keys: #{dupes}" unless dupes.empty?
   end
@@ -161,61 +170,55 @@ class Dropsonde::Metrics
     [
       {
         "description": "An ID that's unique for each checkin to Dujour.",
-        "mode": "NULLABLE",
-        "name": "message_id",
-        "type": "STRING"
+        "mode": 'NULLABLE',
+        "name": 'message_id',
+        "type": 'STRING',
       },
       {
-        "description": "A unique identifier for a site, derived as a hash of the CA certificate and optional seed.",
-        "mode": "NULLABLE",
-        "name": "site_id",
-        "type": "BYTES"
+        "description": 'A unique identifier for a site, derived as a hash of the CA certificate and optional seed.',
+        "mode": 'NULLABLE',
+        "name": 'site_id',
+        "type": 'BYTES',
       },
       {
-        "description": "The name of the product.",
-        "mode": "NULLABLE",
-        "name": "product",
-        "type": "STRING"
+        "description": 'The name of the product.',
+        "mode": 'NULLABLE',
+        "name": 'product',
+        "type": 'STRING',
       },
       {
-        "description": "Version of the project.",
-        "mode": "NULLABLE",
-        "name": "version",
-        "type": "STRING"
+        "description": 'Version of the project.',
+        "mode": 'NULLABLE',
+        "name": 'version',
+        "type": 'STRING',
       },
       {
-        "description": "Time the checkin to Dujour occurred.",
-        "mode": "NULLABLE",
-        "name": "timestamp",
-        "type": "TIMESTAMP"
+        "description": 'Time the checkin to Dujour occurred.',
+        "mode": 'NULLABLE',
+        "name": 'timestamp',
+        "type": 'TIMESTAMP',
       },
       {
-        "description": "IP Address of node checking in to Dujour.",
-        "mode": "NULLABLE",
-        "name": "ip",
-        "type": "STRING"
-      }
+        "description": 'IP Address of node checking in to Dujour.',
+        "mode": 'NULLABLE',
+        "name": 'ip',
+        "type": 'STRING',
+      },
     ]
   end
 
   def skeleton_report
     {
-      "product": "popularity-module",
-      "version": "1.0.0",
+      "product": 'popularity-module',
+      "version": '1.0.0',
       "site_id": siteid,
       "self-service-analytics": {
-        "snapshots": { }
-      }
+        "snapshots": {},
+      },
     }
   end
 
   def generate_guid
-    "%s-%s-%s-%s-%s" % [
-      (0..8).to_a.map{|a| rand(16).to_s(16)}.join,
-      (0..4).to_a.map{|a| rand(16).to_s(16)}.join,
-      (0..4).to_a.map{|a| rand(16).to_s(16)}.join,
-      (0..4).to_a.map{|a| rand(16).to_s(16)}.join,
-      (0..12).to_a.map{|a| rand(16).to_s(16)}.join
-    ]
+    SecureRandom.uuid
   end
 end

data/lib/dropsonde/monkeypatches.rb

@@ -1,17 +1,18 @@
-module Puppet
-  class Module
+# frozen_string_literal: true
 
-    unless Module.method_defined? :"forge_module?"
-      def forge_module?
-        Dropsonde::Cache.forgeModule? self
-      end
+# puppet module class
+class Puppet::Module
+  unless Module.method_defined? :"forge_module?"
+    def forge_module?
+      Dropsonde::Cache.forge_module? self
     end
+  end
 
-    unless Module.method_defined? :forge_slug
-      def forge_slug
-        self.forge_name.tr('/','-') rescue nil
-      end
+  unless Module.method_defined? :forge_slug
+    def forge_slug
+      forge_name.tr('/', '-')
+    rescue StandardError
+      nil
     end
-
   end
 end

data/lib/dropsonde/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Dropsonde
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end