sqlogger 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7fada0c387b433c3fb508705aeb367ce751e94a1
-  data.tar.gz: cbe9067586ae812c40021f17d9b3e19aa6ac6bcf
+  metadata.gz: bbb935a232904d14b9ed45f474a9e577d289820b
+  data.tar.gz: 6724d5159ea9394746412ed20674aed43c590b8d
 SHA512:
-  metadata.gz: 0fca7bbbcfb231c69d9b982518b482be14a15efef924ca92ad423eda6ace636bb9d19d52dc54712d5a7efd1f2061df6e9209ca20adc3d75e9549e417c7c799d0
-  data.tar.gz: d72f581068251375945aa2f3fafdd0aef0ad7bb265a0f1c15100898fc42864602430911c8b0cf69551a63386a2b68ac8db29df3c6a50f32290cdccaf1d90b831
+  metadata.gz: b0581dfeec3e08900b091b76cfc385edd5080e77d2b5b07fdf28120b41c60f6031c2dd78e8c1701c9df28ae04e0856ec93a3896c3183cdc078837032c9b1cfd8
+  data.tar.gz: fae857d8456b34d5d9dd69cee742118c19358cfc1ee8a2b56812a4c155cd5ce13f90172ae84fe0af011f6af30497de57f51cacab6b66ab538b27c0cec59543da

data/README.md

@@ -1,4 +1,5 @@
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](MIT-LICENSE)
+[![Gem Version](https://badge.fury.io/rb/sqlogger.svg)](https://badge.fury.io/rb/sqlogger)
 [![Build Status](https://travis-ci.org/metalels/sqlogger.svg?branch=master)](https://travis-ci.org/metalels/sqlogger)
 [![Code Climate](https://codeclimate.com/github/metalels/sqlogger/badges/gpa.svg)](https://codeclimate.com/github/metalels/sqlogger)
 [![Test Coverage](https://codeclimate.com/github/metalels/sqlogger/badges/coverage.svg)](https://codeclimate.com/github/metalels/sqlogger/coverage)
@@ -10,7 +11,8 @@ Collect 'ActiveRecord sql query' to monitoring system(s).
 <img src="sqlogger_elasticsearch.png" width="580" alt="send sql-log to elasticsearch">
 
 ## Dependency
-Currently only supports Rails 5.1.0beta1 or more.
+Currently supports Rails **3.1.0** and **upper**.  
+Tested minor version between **3.1.0** and **5.1.0beta1**
 
 ## Installation
 Add this line to your application's Gemfile:

data/lib/sqlogger/base.rb

@@ -1,32 +1,40 @@
 module Sqlogger
   module Base
-    def self.logger(opts={})
-      return unless opts[:sql]
-      opts[:name] ||= ""
-      opts[:sql] = format_sql opts[:sql]
-      opts[:binds] = format_sql opts[:binds].strip
-      sql_command = opts[:sql].split.first
-
-      ignore_payloads = Rails.application.config.sqlogger.ignore_payload_names
-      ignore_commands = Rails.application.config.sqlogger.ignore_sql_commands
-      post_targets = Rails.application.config.sqlogger.post_targets
-
-      return if ignore_payloads.include? opts[:name]
-      return if ignore_commands.include? sql_command
-      if post_targets.include?("elasticsearch") || post_targets.include?(:elasticsearch)
-        Thread.start do
-          Sqlogger::Elite::Elasticsearch.post opts
+
+    class << self 
+      def logger opts={}
+        return unless opts[:sql]
+        opts = format_options opts
+
+        if config.ignore_payload_names.include?(opts[:name]) ||
+            config.ignore_sql_commands.include?(sql_command_of opts[:sql])
+          return
         end
+
+        Sqlogger::Elite.post_with opts
       end
-      if post_targets.include?("echo") || post_targets.include?(:echo)
-        Thread.start do
-          Sqlogger::Elite::Echo::post opts
-        end
+
+      def config
+        Rails.application.config.sqlogger
       end
-    end
 
-    def self.format_sql(sql="")
-      sql.gsub(/(\s+|\n)/, " ")
+      private
+
+      def sql_command_of sql=""
+        sql.split.first
+      end
+
+      def format_sql sql=""
+        sql.gsub(/(\s+|\n)/, " ")
+      end
+
+      def format_options opts={}
+        opts[:name] ||= ""
+        opts[:sql] = format_sql opts[:sql]
+        opts[:binds] = format_sql opts[:binds].strip
+        opts
+      end
     end
+
   end
 end

data/lib/sqlogger/elite.rb

@@ -1,2 +1,29 @@
 require "sqlogger/elite/elasticsearch"
 require "sqlogger/elite/echo"
+
+module Sqlogger
+  module Elite
+
+    class << self
+      def post_with opts
+        Thread.start do
+          unique_post_target.each do |post_target|
+            case post_target
+            when "echo"
+              Sqlogger::Elite::Echo::post opts
+            when "elasticsearch"
+              Sqlogger::Elite::Elasticsearch.post opts
+            end
+          end
+        end
+      end
+
+      private
+
+      def unique_post_target
+        Sqlogger::Base.config.post_targets.map(&:to_s).uniq
+      end
+    end
+
+  end
+end

data/lib/sqlogger/elite/echo.rb

@@ -1,31 +1,41 @@
 module Sqlogger
   module Elite
-    module Echo
+    class Echo
       require "open3"
 
-      def self.post(opts={})
-        return unless opts[:sql]
-        echo_file = Rails.application.config.sqlogger.echo.file
-        debug = Rails.application.config.sqlogger.echo.debug
+      class << self 
+        def post opts={}
+          return unless opts[:sql]
+          echo_file = Sqlogger::Base.config.echo.file
+          debug = Sqlogger::Base.config.echo.debug
+          information = information_string_of opts
 
-        info = opts.map do |k,v|
-          "#{k.to_s.upcase}: #{v}#{"ms" if k == :dulation}"
-        end
-        info.unshift "Time: #{Time.now}"
-        info.unshift "PID: #{Process.pid()}"
-        info.push "" << "-" * 10
-        echo_result = Open3.capture3 "echo \"#{info.join("\n")}\" >> #{echo_file}"
-        if debug
-          if echo_result.last.exitstatus == 0
-            Rails.logger.info "Echo ok."
-          else
-            Rails.logger.error "Echo fail."
+          echo_result = Open3.capture3 "echo \"#{information}\" >> #{echo_file}"
+          if debug
+            if echo_result.last.exitstatus == 0
+              Rails.logger.info "Echo ok."
+            else
+              Rails.logger.error "Echo fail."
+            end
+          end
+        rescue => ex
+          if debug
+            Rails.logger.error ex.message
           end
         end
-      rescue => ex
-        if debug
-          Rails.logger.error ex.message
+
+        private
+
+        def information_string_of opts={}
+          info = opts.map do |k,v|
+            "#{k.to_s.upcase}: #{v}#{"ms" if k == :dulation}"
+          end
+          info.unshift "Time: #{Time.now}"
+          info.unshift "PID: #{Process.pid()}"
+          info.push "" << "-" * 10
+          info.join("\n").tr '"', '\''
         end
+
       end
     end
   end

data/lib/sqlogger/elite/elasticsearch.rb

@@ -3,87 +3,102 @@ module Sqlogger
     module Elasticsearch
       require 'net/http'
       require 'uri'
+      class << self 
 
-      def self.post_data_base
-        {
-          "@timestamp" => DateTime.now.to_s,
-          "pid" => Process.pid()
-        }
-      end
+        def post opts={}
+          return unless opts[:sql]
+          post_data = generate_postdata_with opts
+          post_keys = generate_postkeys
 
-      def self.check_name
-        Rails.application.config.sqlogger.elasticsearch.check_name
-      end
+          post_data.reject! do |k, _|
+            !post_keys.include? k
+          end
+          random_hash = Digest::MD5.hexdigest "#{post_data["key"]}#{Time.now.to_i}#{rand(999)}"
 
-      def self.base_url
-        Rails.application.config.sqlogger.elasticsearch.url
-      end
+          https_post "#{url}#{random_hash}", post_data
+        rescue => ex
+          if config.debug
+            Rails.logger.error ex.message
+          end
+        end
 
-      def self.url
-        index_name = Rails.application.config.sqlogger.elasticsearch.index_name
-        "#{base_url}#{"/" unless base_url.end_with?('/')}#{index_name}/#{check_name}/"
-      end
+        private
 
-      def self.post(opts={})
-        return unless opts[:sql]
-        sql_action = opts[:sql].split.first
-        hostname = `hostname`.strip
-        hostname = "CANTGET" if hostname.empty?
-        key = "#{hostname}.queries.#{sql_action}"
-        post_data = self.post_data_base
-        send_keys = Rails.application.config.sqlogger.elasticsearch.post_keys
-        dulation = opts[:dulation] || 0.00
-
-        send_keys.push "check_name"
-        send_keys.push "key"
-        send_keys.push "@timestamp"
-        crit_dul = Rails.application.config.sqlogger.elasticsearch.critical_dulation
-        warn_dul = Rails.application.config.sqlogger.elasticsearch.warning_dulation
-        http_ssl_none_verify = Rails.application.config.sqlogger.elasticsearch.ssl_verify_none
-        post_timeout = Rails.application.config.sqlogger.elasticsearch.post_timeout
-        http_open_timeout = Rails.application.config.sqlogger.elasticsearch.open_timeout
-        http_read_timeout = Rails.application.config.sqlogger.elasticsearch.read_timeout
-        debug = Rails.application.config.sqlogger.elasticsearch.debug
-
-        post_data['server'] = hostname
-        post_data['check_name'] = check_name
-        post_data['status'] = dulation > crit_dul ? 2 : dulation > warn_dul ? 1 : 0
-        post_data['key'] = key
-        post_data['sql'] = opts[:sql]
-        post_data['binds'] = opts[:binds]
-        post_data['dulation'] = dulation
-        post_data['payload'] = opts[:name]
-
-        post_data.reject! do |k, _|
-          !send_keys.include? k
+        def config
+          Sqlogger::Base.config.elasticsearch
         end
 
-        Timeout.timeout(post_timeout) do
-          random_hash = Digest::MD5.hexdigest("#{key}#{Time.now.to_i}#{rand(999)}")
-          uri = URI.parse "#{url}#{random_hash}"
-          http = Net::HTTP.new uri.host, uri.port
-          http.use_ssl = true if base_url =~ /\Ahttps/
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http_ssl_none_verify
-          http.open_timeout = http_open_timeout
-          http.read_timeout = http_read_timeout
-
-          request = Net::HTTP::Post.new(
-            uri.path,
-            "content-type" => "application/json; charset=utf-8"
-          )
-          request.body = JSON.dump post_data
-          response = http.request request
-          if debug
-            Rails.logger.info "Elasticsearch posted #{response.code}."
-          end
-          if response.code.to_i/10 != 20
-            Rails.logger.error "Elasticsearch posting with failure #{response.code}."
+        def https_post full_url, post_data
+          Timeout.timeout(config.post_timeout) do
+            uri = URI.parse full_url
+            http = Net::HTTP.new uri.host, uri.port
+            http.use_ssl = true if base_url =~ /\Ahttps/
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE if config.ssl_verify_none
+            http.open_timeout = config.open_timeout
+            http.read_timeout = config.read_timeout
+
+            request = Net::HTTP::Post.new(
+              uri.path,
+              "content-type" => "application/json; charset=utf-8"
+            )
+            request.body = JSON.dump post_data
+            response = http.request request
+            if config.debug
+              Rails.logger.info "Elasticsearch posted #{response.code}."
+            end
+            if response.code.to_i/10 != 20
+              Rails.logger.error "Elasticsearch posting with failure #{response.code}."
+            end
           end
         end
-      rescue => ex
-        if debug
-          Rails.logger.error ex.message
+
+        def generate_postkeys
+          config.post_keys + %w(check_name key @timestamp)
+        end
+
+        def generate_postdata_with opts
+          hostname = predictive_hostname
+          dulation = opts[:dulation] || 0.00
+          key = "#{hostname}.queries.#{opts[:sql].split.first}"
+
+          {
+            "@timestamp" => DateTime.now.to_s,
+            "pid" => Process.pid(),
+            "status" => status_determined_from(dulation),
+            "server" => hostname,
+            "check_name" => check_name,
+            "key" => key,
+            "sql" => opts[:sql],
+            "binds" => opts[:binds],
+            "dulation" => dulation,
+            "payload" => opts[:name]
+          }
+        end
+
+        def predictive_hostname
+          hostname = `hostname`.strip
+          hostname.empty? ? "CANTGET" : hostname
+        end
+
+        def status_determined_from dulation
+          crit_dul = config.critical_dulation
+          warn_dul = config.warning_dulation
+          dulation > crit_dul ? 2 : dulation > warn_dul ? 1 : 0
+        end
+
+        def check_name
+          config.check_name
+        end
+
+        def base_url
+          config.url
         end
+
+        def url
+          index_name = config.index_name
+          "#{base_url}#{"/" unless base_url.end_with? '/'}#{index_name}/#{check_name}/"
+        end
+
       end
     end
   end

data/lib/sqlogger/monkey/include_active_record_log_subscriber.rb

@@ -0,0 +1,52 @@
+module Sqlogger
+  module Monkey
+    module IncludeActiveRecordLogSubscriber
+      def self.included base
+        base.class_eval do
+          alias_method :sql_without_sqlogger, :sql
+          alias_method :sql, :sql_with_sqlogger
+        end
+      end
+
+      def sql_with_sqlogger event
+        sql_without_sqlogger event
+
+        payload = event.payload
+        binds   = ""
+        unless (payload[:binds] || []).empty?
+          casted_params = sqlogger_type_casted_binds payload[:binds], payload[:type_casted_binds]
+          binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+            sqlogger_render_bind attr, value
+          }.inspect
+        end
+        Sqlogger::Base::logger(
+          sql: payload[:sql],
+          binds: binds,
+          dulation: event.duration.round(1),
+          name: "#{"CACHE " if payload[:cached]}#{payload[:name]}"
+        )
+      end
+      
+      private
+
+      # for support under rails 5.1.0
+      def sqlogger_type_casted_binds binds, casted_binds
+        casted_binds || binds.map do |attr|
+          ActiveRecord::Base.connection.type_cast attr.value_for_database
+        end
+      end
+
+      # for support under rails 5.1.0
+      def sqlogger_render_bind attr, type_casted_value
+        value = if attr.type.binary? && attr.value
+                  "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+                else
+                  type_casted_value
+                end
+
+        [attr.name, value]
+      end
+
+    end
+  end
+end

data/lib/sqlogger/railtie.rb

@@ -4,8 +4,8 @@ module Sqlogger
   class Railtie < Rails::Railtie
     initializer "sqlogger_railtie.configure_rails_initialization" do
       ActiveSupport.on_load :active_record do
-        require 'sqlogger/monkey/active_record/replace_log_subscriber'
-        ActiveRecord::LogSubscriber.send :include, Sqlogger::Monkey::ActiveRecord::ReplaceLogSubscriber
+        require 'sqlogger/monkey/include_active_record_log_subscriber'
+        ActiveRecord::LogSubscriber.send :include, Sqlogger::Monkey::IncludeActiveRecordLogSubscriber
       end
     end
 
@@ -15,7 +15,7 @@ module Sqlogger
 
     #define default values
     config.sqlogger.ignore_payload_names = %w(SCHEMA EXPLAIN)
-    config.sqlogger.ignore_sql_commands = []
+    config.sqlogger.ignore_sql_commands = %w(begin rollback SAVEPOINT RELEASE)
     config.sqlogger.post_targets = []
 
     config.sqlogger.elasticsearch.check_name = "metrics-query"

data/lib/sqlogger/version.rb

@@ -1,3 +1,3 @@
 module Sqlogger
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/tasks/sqlogger_tasks.rake

@@ -16,7 +16,7 @@ namespace :sqlogger do
 
 ## ignore_sql_commands
 ##   set to not logging selected payloads.
-#Rails.application.config.sqlogger.ignore_sql_commands = %w()
+#Rails.application.config.sqlogger.ignore_sql_commands = %w(begin rollback SAVEPOINT RELEASE)
 
 ## post_targets: set to logging target. e.g. %w(elasticsearch echo)
 ##   (current only support echo and elasticsearch)

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sqlogger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - metalels
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-07 00:00:00.000000000 Z
+date: 2017-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.1.0.beta.pre.1
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.1.0.beta.pre.1
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -81,11 +81,11 @@ files:
 - lib/sqlogger/elite.rb
 - lib/sqlogger/elite/echo.rb
 - lib/sqlogger/elite/elasticsearch.rb
-- lib/sqlogger/monkey/active_record/replace_log_subscriber.rb
+- lib/sqlogger/monkey/include_active_record_log_subscriber.rb
 - lib/sqlogger/railtie.rb
 - lib/sqlogger/version.rb
 - lib/tasks/sqlogger_tasks.rake
-homepage: https://github.com/metalels/rails-sqlogger
+homepage: https://github.com/metalels/sqlogger
 licenses:
 - MIT
 metadata: {}

data/lib/sqlogger/monkey/active_record/replace_log_subscriber.rb

@@ -1,33 +0,0 @@
-module Sqlogger
-  module Monkey
-    module ActiveRecord
-      module ReplaceLogSubscriber
-        def self.included(base)
-          base.class_eval do
-            alias_method :sql_without_sqlogger, :sql
-            alias_method :sql, :sql_with_sqlogger
-          end
-        end
-
-        def sql_with_sqlogger(event)
-          sql_without_sqlogger(event);
-
-          payload = event.payload
-          binds   = nil
-          unless (payload[:binds] || []).empty? && payload[:type_casted_binds].present?
-            casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
-            binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-              render_bind(attr, value)
-            }.inspect
-          end
-          Sqlogger::Base::logger(
-            sql: payload[:sql],
-            binds: binds,
-            dulation: event.duration.round(1),
-            name: "#{"CACHE " if payload[:cached]}#{payload[:name]}"
-          )
-        end
-      end
-    end
-  end
-end