lrc_handler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9473feeff833416f0bbce087dc54ef66a565d901
+  data.tar.gz: bbf0f51fb0c7ac76a79875462accac2d4cb08f4f
+SHA512:
+  metadata.gz: 60650906a31af87a9a9f906c8941edcfc8e7f4a74f6e2e081e654b377894af7a98f7e806e755d57fd71d6412fa53189098392026de3f4357fa054a59f4343e84
+  data.tar.gz: e575f7eab704a7e8bb4bb2bfab504531c5a774b7546a22bea8eec4eb2a828705a52fd48922a384d4d1646b56e025274248f12b826c377c4caa2d8126a46c53d9

data/LICENSE.md

@@ -0,0 +1,23 @@
+# Copyright (c) LINKBYNET 2017
+based on chef_handler_foreman gem package (Copyright (c) 2013 Marek Hulan)
+
+MIT License
+
+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,27 @@
+# Description
+
+This gem adds Chef report and attributes handlers that send reports to LRC Project.
+LRC mean LinkByNet Reporter for Chef
+
+## Installation
+
+Since it's released as a gem you can simply run this command under root
+
+```sh
+chef gem install lrc_handler
+```
+
+## Usage:
+
+In /etc/chef/client.rb:
+
+```ruby
+# this adds new functions to chef configuration
+require 'lrc_handler'
+# here you can specify your connection options
+lrc_server_options  :url => 'http://your.server/report'
+# add following line if you want to upload reports
+lrc_reports_upload  true
+# add following line to manage reports verbosity. Allowed values are debug, notice and error
+lrc_reports_level       "notice"
+```

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/lbn_report_chef/lrc_hooks.rb

@@ -0,0 +1,56 @@
+require "#{File.dirname(__FILE__)}/lrc_reporting"
+require "#{File.dirname(__FILE__)}/lrc_resource_reporter"
+require "#{File.dirname(__FILE__)}/lrc_uploader"
+
+module ChefHandlerLrc
+  module LrcHooks
+    attr_reader :lrc_uploader, :lrc_report_handler, :lrc_reporter
+
+    # Provide a chef-client cookbook friendly option
+    def lrc_server_url(url)
+      lrc_server_options(url: url)
+    end
+
+    # {:url => '', ...}
+    def lrc_server_options(options = {})
+      options[:client_key] = client_key || '/etc/chef/client.pem' unless options[:client_key]
+      raise 'No LRC URL! Please provide a URL' unless options[:url]
+      @lrc_uploader = LrcUploader.new(options)
+      # set uploader if handlers are already created
+      @lrc_report_handler.uploader = @lrc_uploader if @lrc_report_handler
+      @lrc_reporter.uploader = @lrc_uploader if @lrc_reporter
+    end
+
+    def lrc_reports_upload(upload, mode = 1)
+      if upload
+        case mode
+        when 1
+          @lrc_reporter           = LrcResourceReporter.new(nil)
+          @lrc_reporter.uploader  = @lrc_uploader
+          @lrc_reporter.log_level = @lrc_reports_level
+          if Chef::Config[:event_handlers].is_a?(Array)
+            Chef::Config[:event_handlers].push @lrc_reporter
+          else
+            Chef::Config[:event_handlers] = [@lrc_reporter]
+          end
+        when 2
+          @lrc_report_handler          = LrcReporting.new
+          @lrc_report_handler.uploader = @lrc_uploader
+          report_handlers << @lrc_report_handler
+          exception_handlers << @lrc_report_handler
+        else
+          raise ArgumentError, 'unknown mode: ' + mode.to_s
+        end
+      end
+    end
+
+    # level can be string error notice debug
+    def reports_log_level(level)
+      raise ArgumentError, 'unknown level: ' + level.to_s unless %w(error notice debug).include?(level)
+      @lrc_reports_level = level
+      if @lrc_reporter
+        @lrc_reporter.log_level = level
+      end
+    end
+  end
+end

data/lib/lbn_report_chef/lrc_reporting.rb

@@ -0,0 +1,75 @@
+require 'chef/handler'
+
+module ChefHandlerLrc
+  class ForemanReporting < ::Chef::Handler
+    attr_accessor :uploader
+
+    def report
+      report                   = { 'host' => node.name, 'reported_at' => Time.now.utc.to_s }
+      report_status            = Hash.new(0)
+      report_status['failed']  = 1 if failed?
+      report_status['applied'] = run_status.updated_resources.count
+      report['status']         = report_status
+
+      # I can't compute much metrics for now
+      metrics                  = {}
+      metrics['resources']     = { 'total' => run_status.all_resources.count }
+
+      times = {}
+      run_status.all_resources.each do |resource|
+        resource_name = resource.resource_name
+        if times[resource_name].nil?
+          times[resource_name] = resource.elapsed_time
+        else
+          times[resource_name] += resource.elapsed_time
+        end
+      end
+      metrics['time']   = times.merge!({ 'total' => run_status.elapsed_time })
+      report['metrics'] = metrics
+
+      logs = []
+      run_status.updated_resources.each do |resource|
+        l = { 'log' => { 'sources' => {}, 'messages' => {}, 'level' => 'notice' } }
+
+        case resource.resource_name.to_s
+        when 'template', 'cookbook_file'
+          message = resource.diff
+        when 'package'
+          message = "Installed #{resource.package_name} package in #{resource.version}"
+        else
+          message = resource.action.to_s
+        end
+        l['log']['messages']['message'] = message
+        l['log']['sources']['source']   = [resource.resource_name.to_s, resource.name].join(' ')
+        # Chef::Log.info("Diff is #{l['log']['messages']['message']}")
+        logs << l
+      end
+
+      # I only set failed to 1 if chef run failed
+      if failed?
+        logs << {
+          'log' => {
+            'sources'  => { 'source' => 'chef' },
+            'messages' => { 'message' => run_status.exception },
+            'level'    => 'err',
+          }
+        }
+      end
+
+      report['logs'] = logs
+      full_report    = { 'report' => report }
+
+      send_report(full_report)
+    end
+
+    private
+
+    def send_report(report)
+      if uploader
+        uploader.foreman_request('/report', report, node.name)
+      else
+        Chef::Log.error 'No uploader registered for foreman reporting, skipping report upload'
+      end
+    end
+  end
+end

data/lib/lbn_report_chef/lrc_resource_reporter.rb

@@ -0,0 +1,210 @@
+module ChefHandlerLrc
+  class LrcResourceReporter < ::Chef::ResourceReporter
+    attr_accessor :uploader, :log_level
+
+    def initialize(*args)
+      @total_up_to_date     = 0
+      @total_skipped        = 0
+      @total_updated        = 0
+      @total_failed         = 0
+      @total_restarted      = 0
+      @total_failed_restart = 0
+      @all_resources        = []
+      super
+    end
+
+    def run_started(run_status)
+      @run_status = run_status
+    end
+
+    def run_completed(_node)
+      @status = 'success'
+      post_reporting_data
+    end
+
+    def run_failed(exception)
+      @exception = exception
+      @status    = 'failure'
+      # If we failed before we received the run_started callback, there's not much we can do
+      # in terms of reporting
+      if @run_status
+        post_reporting_data
+      end
+    end
+
+    def resource_current_state_loaded(new_resource, action, current_resource)
+      super
+      @all_resources.push @pending_update unless @pending_update.nil?
+    end
+
+    def resource_up_to_date(new_resource, action)
+      @total_up_to_date += 1
+      super
+    end
+
+    def resource_skipped(resource, action, conditional)
+      @total_skipped += 1
+      super
+    end
+
+    def resource_updated(new_resource, action)
+      @total_updated   += 1
+      @total_restarted += 1 if action.to_s == 'restart'
+      super
+    end
+
+    def resource_failed(new_resource, action, exception)
+      @total_failed         += 1
+      @total_failed_restart += 1 if action.to_s == 'restart'
+      super
+    end
+
+    def resource_completed(new_resource)
+      if @pending_update && !nested_resource?(new_resource)
+        @pending_update.finish
+        @updated_resources << @pending_update
+        @pending_update = nil
+      end
+    end
+
+    def resource_bypassed(*args)
+      @why_run = true
+    end
+
+    def post_reporting_data
+      if reporting_enabled?
+        run_data = prepare_run_data
+        Chef::Log.info('Sending resource update report to report API ...')
+        Chef::Log.debug run_data.inspect
+        begin
+          Chef::Log.debug('Sending data to report API ...')
+          if uploader
+            uploader.lrc_request('/report', { 'report' => run_data })
+          else
+            Chef::Log.error 'No uploader registered for LRC reporting, skipping report upload'
+          end
+        rescue => e
+          Chef::Log.error "Sending failed with #{e.class} #{e.message}"
+          Chef::Log.error e.backtrace.join("\n")
+        end
+      else
+        Chef::Log.debug('Reporting disabled, skipping report upload')
+      end
+    end
+
+    def prepare_run_data
+      run_data                = {}
+      run_data['host']        = node_name.downcase
+      run_data['reported_at'] = end_time.to_s
+      run_data['status']      = resources_per_status
+
+      run_data['metrics'] = {
+        'resources' => { 'total' => @total_res_count },
+        'time'      => resources_per_time,
+      }
+
+      run_data['logs'] = filter_logs(resources_logs + [chef_log])
+      run_data
+    end
+
+    def resources_per_status
+      if Chef::Config.why_run
+        {
+          'applied'         => 0,
+          'restarted'       => 0,
+          'failed'          => 0,
+          'failed_restarts' => 0,
+          'skipped'         => @total_skipped,
+          'pending'         => @total_updated + @total_restarted + @total_failed + @total_failed_restart,
+        }
+      else
+        {
+          'applied'         => @total_updated,
+          'restarted'       => @total_restarted,
+          'failed'          => @total_failed,
+          'failed_restarts' => @total_failed_restart,
+          'skipped'         => @total_skipped,
+          'pending'         => 0,
+        }
+      end
+    end
+
+    def resources_per_time
+      @run_status.all_resources.inject({}) do |memo, resource|
+        name, time = resource.resource_name.to_s, resource.elapsed_time || 0
+        memo[name] = memo[name] ? memo[name] + time : time
+        memo
+      end
+    end
+
+    def resources_logs
+      @all_resources.map do |resource|
+        action  = resource.new_resource.action
+        message = action.is_a?(Array) ? action.first.to_s : action.to_s
+        message = format_message(message, resource.new_resource)
+        message += " (#{resource.exception.class} #{resource.exception.message})" unless resource.exception.nil?
+        level   =  resource_level(resource)
+        { 'log' => {
+          'sources'  => { 'source' => resource.new_resource.to_s },
+          'messages' => { 'message' => message },
+          'level'    => level,
+        } }
+      end
+    end
+
+    def format_message(message, resource)
+      case resource.resource_name.to_s
+      when 'template', 'cookbook_file'
+        unless resource.diff.nil?
+          message += ' with diff ' + resource.diff.gsub('\\n', "\n")
+        end
+      when 'package'
+        message += " package in #{resource.version}" unless resource.version.nil?
+      else
+        message = resource.action.to_s
+      end
+      message
+    end
+
+    def resource_level(resource)
+      if !resource.exception.nil?
+        return 'err'
+      elsif resource.new_resource.updated
+        return 'notice'
+      else
+        return 'debug'
+      end
+    end
+
+    def chef_log
+      message = 'run'
+      if @status == 'success' && exception.nil?
+        level = 'notice'
+      else
+        message += " (#{exception.class} #{exception.message})"
+        level = 'err'
+      end
+
+      { 'log' => {
+        'sources'  => { 'source' => 'Chef' },
+        'messages' => { 'message' => message },
+        'level'    => level,
+      } }
+    end
+
+    # currently we support only three log levels:
+    #  'debug' means do not filter,
+    #  'notice' updated resources and errors
+    #  'error' means only errors
+
+    def filter_logs(logs)
+      if log_level == 'error'
+        logs.select { |log| log['log']['level'] == 'err' }
+      elsif log_level == 'notice'
+        logs.select { |log| %w(err,notice).include? log['log']['level'] }
+      else
+        logs
+      end
+    end
+  end
+end

data/lib/lbn_report_chef/lrc_uploader.rb

@@ -0,0 +1,23 @@
+require 'net/http'
+require 'uri'
+
+module ChefHandlerLrc
+  class LrcUploader
+    attr_reader :options
+
+    def initialize(opts)
+      @options = opts
+    end
+
+    def lrc_request(path, body, method = 'post')
+      uri  = URI.parse(options[:url])
+      http = Net::HTTP.new(uri.host, uri.port)
+      req = Net::HTTP.const_get(method.capitalize).new("#{uri}#{path}")
+      req.add_field('Accept', 'application/json')
+      req.add_field('Content-Type', 'application/json')
+      req.body = body.to_json
+      response = http.request(req)
+      Chef::Log.info("The report API has return: #{response}")
+    end
+  end
+end

data/lib/lbn_report_chef/version.rb

@@ -0,0 +1,3 @@
+module ChefHandlerLrc
+  VERSION = '0.1.0'.freeze
+end

data/lib/lrc_handler.rb

@@ -0,0 +1,5 @@
+require 'chef'
+require "#{File.dirname(__FILE__)}/lbn_report_chef/version"
+require "#{File.dirname(__FILE__)}/lbn_report_chef/lrc_hooks"
+
+Chef::Config.send :extend, ChefHandlerLrc::LrcHooks

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: lrc_handler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- team-chef
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Chef handlers for lrc reporting
+email:
+- team-chef@linkbynet.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/lbn_report_chef/lrc_hooks.rb
+- lib/lbn_report_chef/lrc_reporting.rb
+- lib/lbn_report_chef/lrc_resource_reporter.rb
+- lib/lbn_report_chef/lrc_uploader.rb
+- lib/lbn_report_chef/version.rb
+- lib/lrc_handler.rb
+homepage: https://git.lbn.fr/chef-tools/lrc_handler
+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.6.11
+signing_key: 
+specification_version: 4
+summary: This gem adds chef handlers so your chef-client can send reports to API
+test_files: []