asana_exception_notifier 0.0.1

data/lib/asana_exception_notifier/helpers/application_helper.rb

@@ -0,0 +1,286 @@
+module AsanaExceptionNotifier
+  # module that is used for formatting numbers using metrics
+  module ApplicationHelper
+  # function that makes the methods incapsulated as utility functions
+
+  module_function
+
+    def permitted_options
+      {
+        asana_api_key:  nil,
+        workspace: nil,
+        assignee:  nil,
+        assignee_status: nil,
+        due_at: nil,
+        due_on: nil,
+        hearted: false,
+        hearts: [],
+        projects: [],
+        followers: [],
+        memberships: [],
+        tags: [],
+        notes: '',
+        name: '',
+        template_path: default_template_path
+      }
+    end
+
+    def multi_request_manager
+      @multi_manager ||= EventMachine::MultiRequest.new
+    end
+
+    def extract_body(env)
+      return if env.blank? || !env.is_a?(Hash)
+      io = env['rack.input']
+      io.rewind if io.respond_to?(:rewind)
+      io.read
+    end
+
+    def show_hash_content(hash)
+      hash.map do |key, value|
+        value.is_a?(Hash) ? show_hash_content(value) : ["#{key}:", value]
+      end.join("\n  ")
+    end
+
+    def tempfile_details(tempfile)
+      file_details = get_extension_and_name_from_file(tempfile)
+      {
+        file: tempfile,
+        path:  tempfile.path
+      }.merge(file_details)
+    end
+
+    # Returns utf8 encoding of the msg
+    # @param [String] msg
+    # @return [String] ReturnsReturns utf8 encoding of the msg
+    def force_utf8_encoding(msg)
+      msg.respond_to?(:force_encoding) && msg.encoding.name != 'UTF-8' ? msg.force_encoding('UTF-8') : msg
+    end
+
+    #  returns the logger used to log messages and errors
+    #
+    # @return [Logger]
+    #
+    # @api public
+    def logger
+      @logger ||= defined?(Rails) ? Rails.logger : ExceptionNotifier.logger
+    end
+
+    def ensure_eventmachine_running(&block)
+      Thread.abort_on_exception = true
+      register_em_error_handler
+      run_em_reactor(&block)
+    end
+
+    def register_em_error_handler
+      EM.error_handler do |error|
+        logger.debug '[AsanaExceptionNotifier]: Error during event loop :'
+        logger.debug "[AsanaExceptionNotifier]: #{log_exception(error)}"
+      end
+    end
+
+    def log_exception(exception)
+      logger.debug exception.inspect
+      log_bactrace(exception) if exception.respond_to?(:backtrace)
+    end
+
+    def log_bactrace(exception)
+      logger.debug exception.backtrace.join("\n")
+    end
+
+    def execute_with_rescue(options = {})
+      yield if block_given?
+    rescue Interrupt
+      rescue_interrupt
+    rescue => error
+      log_exception(error)
+      options.fetch(:value, '')
+    end
+
+    def rescue_interrupt
+      `stty icanon echo`
+      puts "\n Command was cancelled due to an Interrupt error."
+    end
+
+    def run_em_reactor
+      Thread.new do
+        EM.run do
+          EM.defer proc { yield if block_given? }
+        end
+      end.join
+    end
+
+    def template_dir
+      File.expand_path(File.join(root, 'note_templates'))
+    end
+
+    def default_template_path
+      File.join(template_dir, 'asana_exception_notifier.html.erb')
+    end
+
+    def template_path_exist(path)
+      return path if File.exist?(path)
+      fail ArgumentError, "file #{path} doesn't exist"
+    end
+
+    def max_length(rows, index)
+      value = rows.max_by { |array| array[index].to_s.size }
+      value.is_a?(Array) ? value[index] : value
+    end
+
+    def get_hash_rows(hash, rows = [], prefix = '')
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          get_hash_rows(value, rows, key)
+        else
+          rows.push(["#{prefix}#{key}".inspect, escape(value.inspect)])
+        end
+      end
+      rows
+    end
+
+    def link_helper(link)
+      <<-LINK
+      <a href="javascript:void(0)" onclick="AjaxExceptionNotifier.hideAllAndToggle('#{link.downcase}')">#{link.camelize}</a>
+      LINK
+    end
+
+    def escape(text)
+      text.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+    end
+
+    def set_fieldset_key(links, prefix)
+      links[prefix] ||= {}
+      prefix
+    end
+
+    def parse_fieldset_value(options)
+      value = options[:value]
+      value.is_a?(Hash) ? value.reject! { |_new_key, new_value| new_value.is_a?(Hash) } : value
+    end
+
+    # Gets a bidimensional array and create a table.
+    # The first array is used as label.
+    #
+    def mount_table(array, options = {})
+      return '' if array.blank?
+      header = array.shift
+
+      header = header.map { |name| escape(name.to_s.humanize) }
+      rows = array.map { |name| "<tr><td>#{name.join('</td><td>')}</td></tr>" }
+
+      <<-TABLE
+       <table #{hash_to_html_attributes(options)}>
+         <thead><tr><th>#{header.join('</th><th>')}</th></tr></thead>
+         <tbody>#{rows.join}</tbody>
+       </table>
+      TABLE
+    end
+
+    # Mount table for hash, using name and value and adding a name_value class
+    # to the generated table.
+    #
+    def mount_table_for_hash(hash, options = {})
+      return if hash.blank?
+      rows = get_hash_rows(hash, options.fetch('rows', []))
+      mount_table(rows.unshift(%w(Name Value)), { class: 'name_values' }.merge(options))
+    end
+
+    def hash_to_html_attributes(hash)
+      hash.map do |key, value|
+        "#{key}=\"#{value.gsub('"', '\"')}\" "
+      end.join(' ')
+    end
+
+    # returns the root path of the gem
+    #
+    # @return [void]
+    #
+    # @api public
+    def root
+      File.expand_path(File.dirname(__dir__))
+    end
+
+    def get_extension_and_name_from_file(tempfile)
+      path = tempfile.respond_to?(:path) ? tempfile.path : tempfile
+      pathname = Pathname.new(path)
+      extension = pathname.extname
+      {
+        extension: extension,
+        filename: File.basename(pathname, extension),
+        file_path: path
+      }
+    end
+
+    def setup_em_options(options)
+      options.symbolize_keys!
+      options[:em_request] ||= {}
+      options
+    end
+
+    def create_upload_file_part(file)
+      Part.new(name: 'file',
+               body: force_utf8_encoding(File.read(file)),
+               filename:  file,
+               content_type: 'application/zip'
+              )
+    end
+
+    def multipart_file_upload_details(file)
+      boundary = "---------------------------#{rand(10_000_000_000_000_000_000)}"
+      body = MultipartBody.new([create_upload_file_part(file)], boundary)
+      file_upload_request_options(boundary, body, file)
+    end
+
+    def file_upload_request_options(boundary, body, file)
+      {
+        body: body.to_s,
+        head:
+        {
+          'Content-Type' => "multipart/form-data;boundary=#{boundary}",
+          'Content-Length' => File.size(file),
+          'Expect' => '100-continue'
+        }
+      }
+    end
+
+    def get_response_from_request(http, _options)
+      http.respond_to?(:response) ? http.response : http.responses
+    end
+
+    def get_multi_request_values(http_response, key)
+      response_method = key.to_s == 'callback' ? 'response' : 'error'
+      http_response[key.to_sym].values.map { |request| request.send(response_method) }.reject(&:blank?)
+    end
+
+    def split_archive(archive, partial_name, segment_size)
+      indexes = Zip::File.split(archive, segment_size, true, partial_name)
+      archives = Array.new(indexes) do |index|
+        File.join(File.dirname(archive), "#{partial_name}.zip.#{format('%03d', index + 1)}")
+      end if indexes.present?
+      archives.blank? ? [archive] : archives
+    end
+
+    def compress_files(directory, name, files)
+      archive = create_archive(directory, name)
+      ::Zip::File.open(archive, Zip::File::CREATE) do |zipfile|
+        add_files_to_zip(zipfile, files)
+      end
+      archive
+    end
+
+    def add_files_to_zip(zipfile, files)
+      files.each do |file|
+        zipfile.add(file.sub(File.dirname(file) + '/', ''), file)
+      end
+    end
+
+    def create_archive(directory, name)
+      archive = File.join(directory, name + '.zip')
+      archive_dir = File.dirname(archive)
+      FileUtils.mkdir_p(archive_dir) unless File.directory?(archive_dir)
+      FileUtils.rm archive, force: true if File.exist?(archive)
+      archive
+    end
+  end
+end

data/lib/asana_exception_notifier/initializers/zip.rb

@@ -0,0 +1,14 @@
+Zip.setup do |c|
+  c.on_exists_proc = true
+  c.continue_on_exists_proc = true
+  c.unicode_names = false
+  c.default_compression = Zlib::BEST_COMPRESSION
+end
+
+Zip::File.class_eval do
+  singleton_class.send(:alias_method, :original_get_segment_size_for_split, :get_segment_size_for_split)
+
+  def self.get_segment_size_for_split(segment_size)
+    segment_size
+  end
+end

data/lib/asana_exception_notifier/note_templates/asana_exception_notifier.html.erb

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<style type="text/css">
+#asana_exception_notifier {font-size: 11px; font-family: Consolas, monaco, monospace; font-weight: normal; margin: 2em 0 1em 0; text-align: center; color: #444; line-height: 16px; background: #fff;}
+#asana_exception_notifier th, #asana_exception_notifier td {color: #444; line-height: 18px;}
+#asana_exception_notifier a {color: #9b1b1b; font-weight: inherit; text-decoration: none; line-height: 18px;}
+#asana_exception_notifier table {text-align: left; width: 100%;}
+#asana_exception_notifier table td {padding: 5px; border-bottom: 1px solid #ccc;}
+#asana_exception_notifier table td strong {color: #9b1b1b;}
+#asana_exception_notifier table th {padding: 5px; border-bottom: 1px solid #ccc;}
+#asana_exception_notifier table tr:nth-child(2n) td {background: #eee;}
+#asana_exception_notifier table tr:nth-child(2n + 1) td {background: #fff;}
+#asana_exception_notifier tbody {text-align: left;}
+#asana_exception_notifier .name_values td {vertical-align: top;}
+#asana_exception_notifier legend {background-color: #fff;}
+#asana_exception_notifier fieldset {text-align: left; border: 1px dashed #aaa; padding: 0.5em 1em 1em 1em; margin: 1em 2em; color: #444; background-color: #FFF;}
+</style>
+</head>
+<body>
+  <div style="clear:both"></div>
+  <div id="asana_exception_notifier">
+    <div id="all">
+      Show: <%= fieldsets_links %>
+      <% fieldsets.each do |key, value| %>
+      <fieldset class='ajax_exception_notifier_fieldset' id='<%= key %>' style="<%= fieldsets.keys.first != key ? "display:none" : '' %>">
+        <legend>Debug Information for <%= key.to_s.camelize %></legend>
+        <div>
+          <%= mount_table_for_hash(value) %>
+        </div>
+      </fieldset>
+      <% end %>
+    </div>
+  </div>
+  <script type="text/javascript">
+  var AjaxExceptionNotifier = function() {
+    function hideAll(){
+      fields = document.getElementsByClassName('ajax_exception_notifier_fieldset')
+      for (index = 0; index < fields.length; ++index) {
+        AjaxExceptionNotifier.hide(fields[index]);
+      }
+    }
+    function hideAllAndToggle(id) {
+      var n = note(id);
+      var display = n.style.display;
+      hideAll();
+      // Restore original display to allow toggling
+      n.style.display = display;
+      toggle(id)
+      location.href = '#ajax_exception_notifier';
+    }
+    function note(id) {
+      console.log(id);
+      return (document.getElementById(id));
+    }
+    function toggle(id){
+      var el = note(id);
+      if (el.style.display == 'none') {
+        AjaxExceptionNotifier.show(el);
+      } else {
+        AjaxExceptionNotifier.hide(el);
+      }
+    }
+    function show(element) {
+      element.style.display = 'block'
+    }
+    function hide(element) {
+      element.style.display = 'none'
+    }
+    return {
+      show: show,
+      hide: hide,
+      toggle: toggle,
+      hideAll: hideAll,
+      node: note,
+      hideAllAndToggle: hideAllAndToggle
+    }
+  }();
+  /* Additional Javascript */
+  </script>
+</body>
+</html>

data/lib/asana_exception_notifier/note_templates/asana_exception_notifier.text.erb

@@ -0,0 +1,24 @@
+A <%= exception.class.to_s %> occured: <%= exception.message.to_s %>
+<% if exception.respond_to?(:backtrace) && exception.backtrace.present? %>
+File:                    <%=   exception.backtrace.slice(0, 1).join("\n  ")  %>
+<% end %>
+<% if request_data[:ip_address].present? %>
+IP:                      <%= request_data[:ip_address] %>
+<% end %>
+<% if request_data[:session].present? %>
+Session:                      <%= request_data[:session]%>
+<% end %>
+<% if request_data[:url].present? %>
+Request URI:             <%= request_data[:url] %>
+<% end %>
+<% if request_data[:referrer].present? %>
+Referer:                 <%= request_data[:referrer] %>
+<% end %>
+PID:                     <%= process %>
+PWD:                     <%= pwd %>
+Uname:                   <%= uname %>
+Server:                  <%= server %>
+Error time:	             <%= timestamp %>
+<% if request_data[:user_agent].present? %>
+User Agent:	             <%= request_data[:user_agent] %>
+<% end %>

data/lib/asana_exception_notifier/request/client.rb

@@ -0,0 +1,85 @@
+require_relative './core'
+module AsanaExceptionNotifier
+  module Request
+    # class used to make request in deferrable way
+    class Client
+      include AsanaExceptionNotifier::Request::Core
+      include EM::Deferrable
+
+      attr_reader :url, :options, :api_key, :request_name, :request_final, :action
+
+      def initialize(api_key, url, options, &callback)
+        @api_key = api_key
+        @url = url
+
+        @options = options.symbolize_keys
+        @request_name = @options.fetch(:request_name, '')
+        @request_final = @options.fetch(:request_final, false)
+        @action = @options.fetch(:action, '')
+
+        self.callback(&callback)
+
+        send_request_and_rescue
+      end
+
+      def multi_manager
+        @multi_manager ||= options.fetch(:multi_manager, nil)
+      end
+
+      def em_request_options
+        request = setup_em_options(@options).delete(:em_request)
+        params = {
+          head: (request[:head] || {}).merge(
+            'Authorization' => "Bearer #{@api_key}"
+          ),
+          body: request[:body]
+        }
+        super(params)
+      end
+
+      def send_request_and_rescue
+        @http = em_request(@url, @options)
+        send_request
+      rescue => exception
+        log_exception(exception)
+        fail(result: { message: exception })
+      end
+
+      def send_request
+        fetch_data(@options) do |http_response|
+          handle_all_responses(http_response)
+        end
+      end
+
+      def handle_all_responses(http_response)
+        @multi_manager.requests.delete(@http) if @multi_manager.present?
+        if http_response.is_a?(Hash) && %i(callback errback).all? { |key| http_response.symbolize_keys.keys.include?(key) }
+          handle_multi_response(http_response)
+        else
+          handle_response(http_response, @options.fetch(:request_name, ''))
+        end
+      end
+
+      def handle_multi_response(http_response)
+        logger.debug('[AsanaExceptionNotifier]: Handling multi responses')
+        get_multi_request_values(http_response, :callback).each { |request_name, response| handle_response(response, request_name) }
+        get_multi_request_values(http_response, :errback).each { |request_name, response| handle_error(response, request_name) }
+      end
+
+      def handle_error(error, key = '')
+        logger.debug("[AsanaExceptionNotifier]: Task #{key} #{@action} returned:  #{error}")
+        fail(error)
+      end
+
+      def handle_response(http_response, key = '')
+        logger.debug("[AsanaExceptionNotifier]: Task #{key} #{@action} returned:  #{http_response}")
+        data = JSON.parse(http_response)
+        callback_task_creation(data)
+      end
+
+      def callback_task_creation(data)
+        data.fetch('errors', {}).present? ? handle_error(data) : succeed(data)
+      end
+    end
+  end
+end