active_record-sql_analyzer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48238f31887e49755dbac5b74348f9f580dc0b65
-  data.tar.gz: 7c875b3aa9dfdb7e4449f12893ff1ddf2f7effff
+  metadata.gz: 7987c2a8d140ea3c6dc2b13effcad2f810562171
+  data.tar.gz: b62f71e7563c8e92d11ee5baac0ad8722d669780
 SHA512:
-  metadata.gz: ceaaefc3ea471c547e81c4ce227a7fb1b1b13e6d61ea5caffd6d1391b1802fe35af2f5948d7624f1c376e75bfc0c4a89b8be6efb61667ddb5e1faac0bc34e33b
-  data.tar.gz: a89a8a5ae0d6e38c08123a64b0e1a2ec63b8fcfd8641e5eaff55507c122717177c97fc84ab50f605e08ee3a0954ef98a711abc8fa6188253b76ae2ff359cd05c
+  metadata.gz: df3a2c7ea88fbc0b86cc9fdcc9fe94c52c9727ff436ade3f6f06869932f842c24101c33cbefe6bae77e381275572dcb6d4e724741c3bb18cd1ac5888d99da971
+  data.tar.gz: 158608b3e248858f41a0084a6787432932e4860f41d48f876fd6cbbf58c9cad8a2eb7bbbb877eca8092fe50af1c7cc3d5aaf38518771111c6183de0b741b920b

data/lib/active_record/sql_analyzer/background_processor.rb

@@ -19,8 +19,12 @@ module ActiveRecord
       def process_queue
         event = @queue.pop
 
-        event[:caller] = SqlAnalyzer.config[:backtrace_filter_proc].call(event[:caller])
-        event[:sql] = SqlAnalyzer.config[:sql_redactor_complex_proc].call(event[:sql].dup)
+        event[:calls] = event[:calls].map do |call|
+          {
+            caller: SqlAnalyzer.config[:backtrace_filter_proc].call(call[:caller]),
+            sql: SqlAnalyzer.config[:sql_redactor_complex_proc].call(call[:sql].dup)
+          }
+        end
 
         logger = event.delete(:logger)
         logger.filter_event(event)

data/lib/active_record/sql_analyzer/configuration.rb

@@ -117,6 +117,12 @@ module ActiveRecord
         @options[:ambiguous_backtrace_lines] = lines
       end
 
+      # Disable transaction consolidation. With transaction consolidation enabled, the logger will log full transactions
+      # as single statements.
+      def disable_consolidate_transactions
+        @config[:consolidate_transactions] = false
+      end
+
       def [](key)
         @options[key]
       end
@@ -169,6 +175,7 @@ module ActiveRecord
         @options[:analyzers] = []
         @options[:logger_root_path] = Rails.root.join('log')
         @options[:backtrace_filter_proc] = BacktraceFilter.proc
+        @options[:consolidate_transactions] = true
       end
     end
   end

data/lib/active_record/sql_analyzer/monkeypatches/query.rb

@@ -4,27 +4,27 @@ module ActiveRecord
   module SqlAnalyzer
     module Monkeypatches
       module Query
+        QueryAnalyzerCall = Struct.new(:sql, :caller)
+
         def execute(sql, *args)
           return super unless SqlAnalyzer.config
 
-          safe_sql = nil
+          if @_query_analyzer_private_transaction_queue
+            @_query_analyzer_private_transaction_queue << QueryAnalyzerCall.new(sql, caller)
+          else
+            safe_sql = nil
+
+            SqlAnalyzer.config[:analyzers].each do |analyzer|
+              if SqlAnalyzer.config[:should_log_sample_proc].call(analyzer[:name])
+                # This is here rather than above intentionally.
+                # We assume we're not going to be analyzing 100% of queries and want to only re-encode
+                # when it's actually relevant.
+                safe_sql ||= sql.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
 
-          SqlAnalyzer.config[:analyzers].each do |analyzer|
-            if _query_analyzer_private_should_sample_query(analyzer[:name])
-              # This is here rather than above intentionally.
-              # We assume we're not going to be analyzing 100% of queries and want to only re-encode
-              # when it's actually relevant.
-              safe_sql ||= sql.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
-
-              if safe_sql =~ analyzer[:table_regex]
-                SqlAnalyzer.background_processor << {
-                  sql: safe_sql,
-                  caller: caller,
-                  logger: analyzer[:logger_instance],
-                  tag: Thread.current[:_ar_analyzer_tag],
-                  request_path: Thread.current[:_ar_analyzer_request_path],
-                  transaction: @_query_analyzer_private_transaction_uuid
-                }
+                if safe_sql =~ analyzer[:table_regex]
+                  SqlAnalyzer.background_processor <<
+                    _query_analyzer_private_query_stanza([QueryAnalyzerCall.new(safe_sql, caller)], analyzer)
+                end
               end
             end
           end
@@ -32,39 +32,67 @@ module ActiveRecord
           super
         end
 
-        # Whether or not we should sample the query. If it's part of a transaction, check whether we
-        # are sampling the transaction. Otherwise, run the sample proc.
-        def _query_analyzer_private_should_sample_query(analyzer_name)
-          if @_query_analyzer_private_transaction_uuid.present?
-            @_query_analyzer_private_should_sample_transaction[analyzer_name]
-          else
-            SqlAnalyzer.config[:should_log_sample_proc].call(analyzer_name)
+        # Drain the transaction query queue. Log the current transaction out to any logger that samples it.
+        def _query_analyzer_private_drain_transaction_queue
+          reencoded_calls = nil
+
+          SqlAnalyzer.config[:analyzers].each do |analyzer|
+            if SqlAnalyzer.config[:should_log_sample_proc].call(analyzer[:name])
+              # Again, trying to only re-encode and join strings if the transaction is actually
+              # sampled.
+              reencoded_calls ||= @_query_analyzer_private_transaction_queue.map do |call|
+                QueryAnalyzerCall.new(call.sql.encode(Encoding::UTF_8, invalid: :replace, undef: :replace), call.caller)
+              end
+
+              matching_calls = reencoded_calls.select do |call|
+                (call.sql =~ /^(UPDATE|INSERT|DELETE)/) || (call.sql =~ analyzer[:table_regex])
+              end
+
+              if matching_calls.any?
+                # Add back in the begin and commit statements, using the correct call stack references
+                if reencoded_calls.first.sql == 'BEGIN'
+                  matching_calls.unshift(reencoded_calls.first)
+                end
+
+                if ['COMMIT', 'ROLLBACK'].include? reencoded_calls.last.sql
+                  matching_calls << reencoded_calls.last
+                end
+
+                SqlAnalyzer.background_processor <<
+                  _query_analyzer_private_query_stanza(matching_calls, analyzer)
+              end
+            end
           end
         end
 
-        # Calculate hash of analyzer_name -> boolean representing whether we should sample the
-        # whole transaction for this analyzer.
-        def _query_analyzer_private_calculate_sampling_for_all_analyzers
-          SqlAnalyzer.config[:analyzers].map do |analyzer|
-            [analyzer[:name], SqlAnalyzer.config[:should_log_sample_proc].call(analyzer[:name])]
-          end.to_h
+        # Helper method to construct the event for a query or transaction.
+        # safe_sql [string]: SQL statement or combined SQL statement for transaction
+        # calls: A list of QueryAnalyzerCall objects to be turned into call hashes
+        def _query_analyzer_private_query_stanza(calls, analyzer)
+          {
+            # Calls are of the format {sql: String, caller: String}
+            calls: calls.map(&:to_h),
+            logger: analyzer[:logger_instance],
+            tag: Thread.current[:_ar_analyzer_tag],
+            request_path: Thread.current[:_ar_analyzer_request_path],
+          }
         end
 
         def transaction(requires_new: nil, isolation: nil, joinable: true)
-          must_clear_uuid = false
+          must_clear_transaction = false
 
-          if @_query_analyzer_private_transaction_uuid.nil? then
-            must_clear_uuid = true
-            @_query_analyzer_private_transaction_uuid = SecureRandom.uuid
-            @_query_analyzer_private_should_sample_transaction =
-               _query_analyzer_private_calculate_sampling_for_all_analyzers
+          if SqlAnalyzer.config[:consolidate_transactions]
+            if @_query_analyzer_private_transaction_queue.nil?
+              must_clear_transaction = true
+              @_query_analyzer_private_transaction_queue = []
+            end
           end
 
           super
         ensure
-          if must_clear_uuid
-            @_query_analyzer_private_transaction_uuid = nil
-            @_query_analyzer_private_should_sample_transaction = nil
+          if must_clear_transaction
+            _query_analyzer_private_drain_transaction_queue
+            @_query_analyzer_private_transaction_queue = nil
           end
         end
       end

data/lib/active_record/sql_analyzer/redacted_logger.rb

@@ -3,19 +3,43 @@ module ActiveRecord
     class RedactedLogger < CompactLogger
       def filter_event(event)
         # Determine if we're doing extended tracing or only the first
-        if config[:ambiguous_tracers].any? { |regex| event[:caller].first =~ regex }
-          event[:caller] = event[:caller][0, config[:ambiguous_backtrace_lines]].join(", ")
+        calls = event.delete(:calls).map do |call|
+          {sql: filter_sql(call[:sql]), caller: filter_caller(call[:caller])}
+        end
+
+        # De-duplicate redacted calls to avoid many transactions with looping "N+1" queries.
+        calls.uniq!
+
+        event[:sql] = calls.map { |call| call[:sql] }
+        event[:caller] = calls.map { |call| call[:caller] }.join(';; ')
+
+        if event[:sql].size == 1
+          event[:sql] = event[:sql].first
         else
-          event[:caller] = event[:caller].first
+          event[:sql] = event[:sql].join('; ') + ';'
+        end
+      end
+
+      def filter_caller(kaller)
+        kaller = if config[:ambiguous_tracers].any? { |regex| kaller.first =~ regex }
+          kaller[0, config[:ambiguous_backtrace_lines]].join(", ")
+        else
+          kaller.first
         end
 
         config[:backtrace_redactors].each do |redactor|
-          event[:caller].gsub!(redactor.search, redactor.replace) if event[:caller]
+          kaller.gsub!(redactor.search, redactor.replace)
         end
 
+        kaller
+      end
+
+      def filter_sql(sql)
         config[:sql_redactors].each do |redactor|
-          event[:sql].gsub!(redactor.search, redactor.replace) if event[:sql]
+          sql.gsub!(redactor.search, redactor.replace)
         end
+
+        sql
       end
     end
   end

data/lib/active_record/sql_analyzer/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module SqlAnalyzer
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/spec/active_record/sql_analyzer/background_processor_spec.rb

@@ -3,7 +3,7 @@ RSpec.describe ActiveRecord::SqlAnalyzer::BackgroundProcessor do
 
   let(:instance) { described_class.new }
 
-  let(:event) { {caller: "CALLER", sql: "SQL", logger: logger} }
+  let(:event) { {calls: [{caller: "CALLER", sql: "SQL"}], logger: logger} }
 
   let(:logger) do
     Class.new do
@@ -34,10 +34,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::BackgroundProcessor do
 
     expect(logger.events).to eq(
       [
-        {
+        calls: [{
           caller: "BFP CALLER",
           sql: "CSRP SQL"
-        }
+        }]
       ]
     )
   end

data/spec/active_record/sql_analyzer/end_to_end_spec.rb

@@ -55,6 +55,11 @@ RSpec.describe "End to End" do
     wait_for_pop
   end
 
+  def transaction
+    DBConnection.connection.transaction { yield }
+    wait_for_pop
+  end
+
   it "does not log with a non-matching table" do
     execute "SELECT * FROM nonmatching_table"
 
@@ -105,63 +110,135 @@ RSpec.describe "End to End" do
   end
 
   it "logs multiple queries in a transaction correctly" do
-    DBConnection.connection.transaction do
-      4.times { execute "SELECT * FROM matching_table WHERE id = 4321" }
-      3.times { execute "SELECT * FROM matching_table WHERE test_string = 'abc'" }
+    transaction do
+      execute "SELECT * FROM matching_table WHERE id = 4321"
+      execute "SELECT * FROM matching_table WHERE test_string = 'abc'"
     end
 
-    DBConnection.connection.transaction do
-      2.times { execute "SELECT * FROM matching_table WHERE test_string LIKE 'abc'" }
-      execute "SELECT * FROM matching_table WHERE id > 2 and id < 4"
+    2.times do
+      transaction do
+        execute "SELECT * FROM matching_table WHERE test_string = 'abc'"
+        execute "SELECT * FROM matching_table WHERE id = 4321"
+      end
     end
 
-    id_eq_sha = log_reverse_hash[4]
-    str_eq_sha = log_reverse_hash[3]
-    str_like_sha = log_reverse_hash[2]
-    id_gt_sha = log_reverse_hash[1]
-
-    expect(log_def_hash[id_gt_sha]["sql"]).to include("id = [REDACTED] and id = [REDACTED]")
-    expect(log_def_hash[str_like_sha]["sql"]).to include("test_string LIKE '[REDACTED]'")
-    expect(log_def_hash[id_gt_sha]["transaction"]).to eq(log_def_hash[str_like_sha]["transaction"])
+    transaction_executed_once_sha = log_reverse_hash[1]
+    transaction_executed_twice_sha = log_reverse_hash[2]
 
-    expect(log_def_hash[id_eq_sha]["sql"]).to include("id = [REDACTED]")
-    expect(log_def_hash[str_eq_sha]["sql"]).to include("test_string = '[REDACTED]'")
-    expect(log_def_hash[str_eq_sha]["transaction"]).to eq(log_def_hash[id_eq_sha]["transaction"])
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+      "BEGIN; " \
+      "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+      "SELECT * FROM matching_table WHERE test_string = '[REDACTED]'; " \
+      "COMMIT;")
 
-    expect(log_def_hash[str_like_sha]["transaction"]).to_not eq(log_def_hash[id_eq_sha]["transaction"])
+    expect(log_def_hash[transaction_executed_twice_sha]["sql"]).to eq(
+     "BEGIN; " \
+     "SELECT * FROM matching_table WHERE test_string = '[REDACTED]'; " \
+     "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+     "COMMIT;")
   end
 
   it "Logs nested transactions correctly" do
-    DBConnection.connection.transaction do
+    transaction do
       execute "SELECT * FROM matching_table WHERE id = 4321"
-      DBConnection.connection.transaction do
-        2.times { execute "SELECT * FROM matching_table WHERE test_string = 'abc'" }
+      transaction do
+        execute "SELECT * FROM matching_table WHERE test_string = 'abc'"
       end
     end
 
+    transaction_executed_once_sha = log_reverse_hash[1]
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+        "BEGIN; " \
+        "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+        "SELECT * FROM matching_table WHERE test_string = '[REDACTED]'; " \
+        "COMMIT;")
+  end
 
-    id_sha = log_reverse_hash[1]
-    str_sha = log_reverse_hash[2]
+  it "Logs transactions with inserts correctly" do
+    transaction do
+      execute "INSERT INTO matching_table (test_string) VALUES ('test_value')"
+      execute "SELECT * FROM matching_table WHERE id = 4321"
+    end
 
-    expect(log_def_hash[id_sha]["transaction"]).to eq(log_def_hash[str_sha]["transaction"])
-    expect(log_def_hash[str_sha]["transaction"]).not_to be_nil
+    transaction_executed_once_sha = log_reverse_hash[1]
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+          "BEGIN; " \
+            "INSERT INTO matching_table (REDACTED_COLUMNS) VALUES ('[REDACTED]'); " \
+            "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+            "COMMIT;")
   end
 
-  it "Logs empty transactions correctly" do
-    DBConnection.connection.transaction do
+  it "Logs mixed matching-nonmatching selects correctly" do
+    transaction do
       execute "SELECT * FROM matching_table WHERE id = 4321"
+      execute "SELECT * FROM nonmatching_table WHERE id = 4321"
     end
 
-    2.times { execute "SELECT * FROM matching_table WHERE test_string = 'abc'" }
+    transaction_executed_once_sha = log_reverse_hash[1]
 
-    id_sha = log_reverse_hash[1]
-    str_sha = log_reverse_hash[2]
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+      "BEGIN; " \
+      "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+      "COMMIT;")
+  end
 
-    expect(log_def_hash[id_sha]["sql"]).to include("id = [REDACTED]")
-    expect(log_def_hash[str_sha]["sql"]).to include("test_string = '[REDACTED]'")
+  it "Logs transaction with repeated selects correctly" do
+    transaction do
+      execute "SELECT * FROM matching_table WHERE id = 4321"
+      ['blah', 'bloo'].each do |s|
+        execute "SELECT * FROM matching_table WHERE test_string = '#{s}'"
+      end
+    end
+
+    transaction_executed_once_sha = log_reverse_hash[1]
 
-    expect(log_def_hash[id_sha]["transaction"]).not_to be_nil
-    expect(log_def_hash[str_sha]["transaction"]).to be_nil
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+                                                                    "BEGIN; " \
+      "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+      "SELECT * FROM matching_table WHERE test_string = '[REDACTED]'; " \
+      "COMMIT;")
+  end
+
+  it "Logs transaction with repeated inserts correctly" do
+    transaction do
+      execute "SELECT * FROM matching_table WHERE id = 4321"
+      2.times do
+        execute "INSERT INTO matching_table (test_string) VALUES ('test_value')"
+      end
+    end
+
+    transaction_executed_once_sha = log_reverse_hash[1]
+
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+                                                                    "BEGIN; " \
+      "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+      "INSERT INTO matching_table (REDACTED_COLUMNS) VALUES ('[REDACTED]'); " \
+      "COMMIT;")
+  end
+
+
+  it "Logs mixed matching-nonmatching with inserts correctly" do
+    transaction do
+      execute "SELECT * FROM matching_table WHERE id = 4321"
+      execute "INSERT INTO nonmatching_table (id) VALUES (1)"
+    end
+
+    transaction_executed_once_sha = log_reverse_hash[1]
+
+    expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+                                                                    "BEGIN; " \
+      "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+      "INSERT INTO nonmatching_table (REDACTED_COLUMNS) VALUES ('[REDACTED]'); " \
+      "COMMIT;")
+  end
+
+  it "Does not log nonmatching-only queries" do
+    transaction do
+      execute "SELECT * FROM nonmatching_table WHERE id = 4321"
+      execute "SELECT * FROM nonmatching_table WHERE id = 4321"
+    end
+
+    expect(log_def_hash.size).to eq(0)
   end
 
   context "Selectively sampling" do
@@ -179,24 +256,29 @@ RSpec.describe "End to End" do
 
       expect(log_def_hash.size).to eq(1)
       expect(log_def_hash.map { |_hash, query| query['sql'] }).to eq([
-        "SELECT * FROM matching_table WHERE id = [REDACTED]"])
+        "SELECT * FROM matching_table WHERE id = '[REDACTED]'"])
     end
 
     it "Samples some but not other whole transactions" do
-      DBConnection.connection.transaction do
+      transaction do
         execute "SELECT * FROM matching_table WHERE id = 1"
         execute "SELECT * FROM matching_table WHERE test_string = 'abc'"
       end
 
-      DBConnection.connection.transaction do
+      transaction do
         execute "SELECT * FROM matching_table WHERE id = 1 and test_string = 'abc'"
         execute "SELECT * FROM matching_table WHERE id > 4 and id < 8"
       end
 
-      expect(log_def_hash.size).to eq(2)
-      expect(Set.new(log_def_hash.map { |_hash, query| query['sql'] })).to eq(Set.new([
-        "SELECT * FROM matching_table WHERE id = [REDACTED]",
-        "SELECT * FROM matching_table WHERE test_string = '[REDACTED]'"]))
+
+      transaction_executed_once_sha = log_reverse_hash[1]
+
+      expect(log_def_hash.size).to eq(1)
+      expect(log_def_hash[transaction_executed_once_sha]["sql"]).to eq(
+        "BEGIN; " \
+        "SELECT * FROM matching_table WHERE id = '[REDACTED]'; " \
+        "SELECT * FROM matching_table WHERE test_string = '[REDACTED]'; " \
+        "COMMIT;")
     end
   end
 

data/spec/active_record/sql_analyzer/redacted_logger_spec.rb

@@ -21,8 +21,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
           [/erb_erb_[0-9]+_[0-9]+/, ""]
         ]
       end
+
       # All raw SQL should be valid :)
-      expect { parser.scan_str(event[:sql]) }.not_to raise_exception if event[:sql].present?
+      event_sql_list = event[:calls].map { |call| call[:sql] }
+      expect { event_sql_list.map { |sql| parser.scan_str sql } }.not_to raise_exception if event_sql_list.any?(&:present?)
     end
 
     after do
@@ -33,8 +35,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "ambiguous backtraces" do
       let(:event) do
         {
-          caller: %w(ambiguous foo bar),
-          sql: ""
+          calls: [{
+            caller: %w(ambiguous foo bar),
+            sql: "",
+          }]
         }
       end
 
@@ -52,8 +56,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "backtrace" do
       let(:event) do
         {
-          caller: %w(foo-bar-erb_erb_1_5),
-          sql: ""
+          calls: [{
+            caller: %w(foo-bar-erb_erb_1_5),
+            sql: "",
+          }]
         }
       end
 
@@ -65,8 +71,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "sql quoted" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name = 'hello\\'s name'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name = 'hello\\'s name'",
+          }]
         }
       end
 
@@ -78,8 +86,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "sql quoted multiple WHERE" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name = 'hello\\'s name' AND age = '21'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name = 'hello\\'s name' AND age = '21'",
+          }]
         }
       end
 
@@ -92,8 +102,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "sql escaped and quoted" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name = 'hello\\\'s name'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name = 'hello\\\'s name'",
+          }]
         }
       end
 
@@ -105,8 +117,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "sql case insensitivity" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name lIkE 'hello'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name lIkE 'hello'",
+          }]
         }
       end
 
@@ -118,8 +132,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "sql" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE id = 1234"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE id = 1234",
+          }]
         }
       end
 
@@ -131,8 +147,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "like quoted" do
       let(:event) do
         {
-          caller: [""],
-          sql: %{SELECT * FROM foo WHERE name LIKE 'A \\'quoted\\' value.' OR name LIKE "another ""quoted"" \\"value\\""}
+          calls: [{
+            caller: [""],
+            sql: %{SELECT * FROM foo WHERE name LIKE 'A \\'quoted\\' value.' OR name LIKE "another ""quoted"" \\"value\\""},
+          }]
         }
       end
 
@@ -144,8 +162,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "like escaped and quoted" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name LIKE 'A \\\'quoted\\\' value.'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name LIKE 'A \\\'quoted\\\' value.'",
+          }]
         }
       end
 
@@ -157,8 +177,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "in quoted" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name IN ('A ''quoted'' value.')"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name IN ('A ''quoted'' value.')",
+          }]
         }
       end
 
@@ -170,8 +192,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "in escaped and quoted" do
       let(:event) do
         {
-          caller: [""],
-          sql: %{SELECT * FROM foo WHERE name IN ('A ''quoted'' value.', "another ""quoted"" \\"value\\"")}
+          calls: [{
+            caller: [""],
+            sql: %{SELECT * FROM foo WHERE name IN ('A ''quoted'' value.', "another ""quoted"" \\"value\\"")},
+          }]
         }
       end
 
@@ -183,8 +207,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "between strings" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name BETWEEN 'A value.' AND 'Another value'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name BETWEEN 'A value.' AND 'Another value'",
+          }]
         }
       end
 
@@ -196,8 +222,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "between strings with escaped quotes" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name BETWEEN 'A ''quoted'' value.' AND 'Another \\'value\\''"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name BETWEEN 'A ''quoted'' value.' AND 'Another \\'value\\''",
+          }]
         }
       end
 
@@ -209,8 +237,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "in with = and other where clauses" do
       let(:event) do
         {
-          caller: [""],
-          sql: "SELECT * FROM foo WHERE name IN ('value=') AND name = 'value'"
+          calls: [{
+            caller: [""],
+            sql: "SELECT * FROM foo WHERE name IN ('value=') AND name = 'value'",
+          }]
         }
       end
 
@@ -222,8 +252,10 @@ RSpec.describe ActiveRecord::SqlAnalyzer::RedactedLogger do
     context "insert" do
       let(:event) do
         {
-          caller: [""],
-          sql: "INSERT INTO `boom` (`bam`, `foo`) VALUES ('howdy', 'dowdy')"
+          calls: [{
+            caller: [""],
+            sql: "INSERT INTO `boom` (`bam`, `foo`) VALUES ('howdy', 'dowdy')",
+          }]
         }
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record-sql_analyzer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Zachary Anker
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2016-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord