ruby_memcheck 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5d70104059dfe613b15fbb637b263ef6829e69e715d6cbeee472ab4715d0ae9
-  data.tar.gz: 1827ee868afd8bb2bc4929d82d0c8ebefea2c4ef43547f9c509a38fed693489d
+  metadata.gz: 4cd707ffa4ebdb25945d2d2654659a38c2272a0e73678d9c9f58e655e19b3cc6
+  data.tar.gz: df247c2a1e77374ad3c9521b1a3f2554c443fa80e33d50cd948727821a3267d5
 SHA512:
-  metadata.gz: d5b15eaaae74eb54957aaec9e460b59b07abdc0c922f2bb94f4e9f63504243caa2969a43c6dbfb075e51399c05fc1295ecb5996c381fd9f6ff9e10dae8d0dc4e
-  data.tar.gz: 9fa9bc3f6374ffdfc5e0c80b6bd22e13aa26300b3b171895cc729eded1b1a446400912ebfcdc08c9ef3ca5ad3bca851a9222b309e51e8d82aee2d0560e47dcc9
+  metadata.gz: 7b4c337a38ad04be648365f4de828187524f11f67699aaa187182d906e4dbf922d84767003e4bab79572c0b3c41fe908c2bb23b1029b1d49360a9c399df5010f
+  data.tar.gz: 3c73f128a88b0eabce497b0ebb464166ccc541dbf5ec0e03b1951d8e1569abd6123a48a454b6a2e9b808c95770ea922b6e027db8c2be2a458d5f0b53f3cb74bc

data/.github/workflows/test.yml

@@ -6,9 +6,9 @@ jobs:
     strategy:
       matrix:
         entry:
-          - { ruby: '2.6', allowed-failure: false }
           - { ruby: '2.7', allowed-failure: false }
           - { ruby: '3.0', allowed-failure: false }
+          - { ruby: '3.1', allowed-failure: false }
           - { ruby: ruby-head, allowed-failure: false }
     name: ruby ${{ matrix.entry.ruby }}
     steps:

data/.rubocop.yml

@@ -8,3 +8,6 @@ AllCops:
 Style/GlobalVars:
   Exclude:
     - test/ruby_memcheck/ext/extconf.rb
+
+Layout/CommentIndentation:
+  AllowForAlignment: true

data/README.md

@@ -26,16 +26,19 @@ Only gems with native extensions can use this gem. If your gem is written in pla
 
 This gem runs Valgrind with the `--xml` option to generate an XML of all the errors. It will then parse the XML and use various heuristics based on the type of the error and the stack trace to filter out errors that are false positives.
 
+For more details, read [this blog post](https://blog.peterzhu.ca/ruby-memcheck/).
+
 ### Limitations
 
 Because of the aggressive heuristics used to filter out false positives, there are various limitations of what this gem can detect.
 
 1. This gem is only expected to work on Linux.
+1. This gem runs your gem's test suite to find errors and memory leaks. It will only be able to report errors on code paths that are covered by your tests. So make sure your test suite has good coverage!
 1. It will not find memory leaks in Ruby. It filters out everything in Ruby.
 1. It will not find memory leaks of allocations that occurred in Ruby (even if the memory leak is caused by your native extension).
 
     An example of this is if a string is allocated in Ruby, passed into your native extension, you change the pointer of the string without freeing the contents, so the contents of the string becomes leaked.
-1. To filter out false-positives, it will only find definite leaks (i.e. memory regions with no pointers to it). It will not find possible leaks (i.e. memory regions with pointers to it).
+1. To filter out false positives, it will only find definite leaks (i.e. memory regions with no pointers to it). It will not find possible leaks (i.e. memory regions with pointers to it).
 1. It will not find leaks that occur in the `Init` function of your native extension.
 1. It will not find uses of undefined values (e.g. conditional jumps depending on undefined values). This is just a technical limitation that has not been solved yet (contributions welcome!).
 
@@ -67,6 +70,7 @@ The easiest way to use this gem is to use it on your test suite (minitest or RSp
     ```ruby
     RubyMemcheck.config(binary_name: "your_binary_name")
     ```
+
 1. Setup the test task for your test framework.
     - **minitest**
     
@@ -105,18 +109,30 @@ The easiest way to use this gem is to use it on your test suite (minitest or RSp
       For example, if your Rakefile looked like this before:
 
       ```ruby
-      RubyMemcheck::RSpec::RakeTask.new(spec: :compile)
+      RSpec::Core::RakeTask.new(spec: :compile)
       ```
 
       You can change it to look like this:
 
       ```ruby
-      RubyMemcheck::RSpec::RakeTask.new(spec: :compile)
+      RSpec::Core::RakeTask.new(spec: :compile)
       namespace :spec do
         RubyMemcheck::RSpec::RakeTask.new(valgrind: :compile)
       end
       ```
 
+1. Add the following line to your `test_helper.rb` or `spec_helper.rb`:
+
+    ```ruby
+    at_exit { GC.start }
+    ```
+
+    This will run a major garbage collection cycle before the Ruby process shuts down. This will ensure that any remaining Ruby objects are collected which will prevent Valgrind from reporting false positives.
+
+    It is safest to add the line above at the very first line of `test_helper.rb` or `spec_helper.rb`.
+
+    - **For minitest:** It is important that the line above is added BEFORE the `require "minitest/autorun"` line.
+
 1. You're ready to run your test suite with Valgrind using `rake test:valgrind` or `rake spec:valgrind`! Note that this will take a while to run because Valgrind will make Ruby significantly slower.
 1. (Optional) If you find false positives in the output, you can create Valgrind suppression files. See the [`Suppression files`](#suppression-files) section for more details.
 
@@ -140,7 +156,7 @@ When you run `RubyMemcheck.config`, you are creating a default `RubyMemcheck::Co
 
 If you find false positives in the output, you can create suppression files in a `suppressions` directory in the root directory of your gem. In this directory, you can create [Valgrind suppression files](https://wiki.wxwidgets.org/Valgrind_Suppression_File_Howto).
 
-The most basic suppression file is `your_binary_name_ruby.supp`. If you want some suppressions for only specific versions of Ruby, you can add the Ruby version to the filename. For example, `your_binary_name_ruby-3.supp` will suppress for any Rubies with a major version of 3 (e.g. 3.0.0, 3.1.1, etc.), while suppression file `your_binary_name_ruby-3.1.supp` will only be used for Ruby with a major and minor version of 3.1 (e.g. 3.1.0, 3.1.1, etc.).
+The most basic suppression file is `ruby.supp`. If you want some suppressions for only specific versions of Ruby, you can add the Ruby version to the filename. For example, `ruby-3.supp` will suppress for any Rubies with a major version of 3 (e.g. 3.0.0, 3.1.1, etc.), while suppression file `ruby-3.1.supp` will only be used for Ruby with a major and minor version of 3.1 (e.g. 3.1.0, 3.1.1, etc.).
 
 ## Success stories
 

data/lib/ruby_memcheck/configuration.rb

@@ -31,7 +31,7 @@ module RubyMemcheck
       /\Arb_yield/,
     ].freeze
 
-    attr_reader :binary_name, :ruby, :valgrind, :valgrind_options, :valgrind_suppressions_dir,
+    attr_reader :binary_name, :ruby, :valgrind, :valgrind_options, :valgrind_suppression_files,
       :valgrind_generate_suppressions, :skipped_ruby_functions, :valgrind_xml_dir, :output_io
     alias_method :valgrind_generate_suppressions?, :valgrind_generate_suppressions
 
@@ -50,7 +50,9 @@ module RubyMemcheck
       @ruby = ruby
       @valgrind = valgrind
       @valgrind_options = valgrind_options
-      @valgrind_suppressions_dir = File.expand_path(valgrind_suppressions_dir)
+      @valgrind_suppression_files =
+        get_valgrind_suppression_files(File.join(__dir__, "../../suppressions")) +
+        get_valgrind_suppression_files(valgrind_suppressions_dir)
       @valgrind_generate_suppressions = valgrind_generate_suppressions
       @skipped_ruby_functions = skipped_ruby_functions
       @output_io = output_io
@@ -80,7 +82,7 @@ module RubyMemcheck
         "ulimit -s unlimited && ",
         valgrind,
         valgrind_options,
-        get_valgrind_suppression_files(valgrind_suppressions_dir).map { |f| "--suppressions=#{f}" },
+        valgrind_suppression_files.map { |f| "--suppressions=#{f}" },
         valgrind_generate_suppressions ? "--gen-suppressions=all" : "",
         ruby,
         args,
@@ -90,13 +92,22 @@ module RubyMemcheck
     private
 
     def get_valgrind_suppression_files(dir)
+      dir = File.expand_path(dir)
+
       full_ruby_version = "#{RUBY_ENGINE}-#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}"
       versions = [full_ruby_version]
       (0..3).reverse_each { |i| versions << full_ruby_version.split(".")[0, i].join(".") }
       versions << RUBY_ENGINE
 
       versions.map do |version|
-        Dir[File.join(dir, "#{binary_name}_#{version}.supp")]
+        old_format_files = Dir[File.join(dir, "#{binary_name}_#{version}.supp")]
+
+        unless old_format_files.empty?
+          warn("ruby_memcheck: please migrate your suppression filenames from " \
+            "`gem_name_ruby-3.1.0.supp` to `ruby-3.1.0.supp` (drop the gem name from the filename)")
+        end
+
+        old_format_files + Dir[File.join(dir, "#{version}.supp")]
       end.flatten
     end
   end

data/lib/ruby_memcheck/test_task_reporter.rb

@@ -33,9 +33,11 @@ module RubyMemcheck
       xml_files.each do |file|
         Nokogiri::XML::Reader(File.open(file)).each do |node|
           next unless node.name == "error" && node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+
           error_xml = Nokogiri::XML::Document.parse(node.outer_xml).root
           error = ValgrindError.new(configuration, error_xml)
           next if error.skip?
+
           @errors << error
         end
       end

data/lib/ruby_memcheck/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyMemcheck
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/suppressions/ruby.supp

@@ -0,0 +1,21 @@
+{
+  On platforms where memcpy is safe for overlapped memory, the compiler will sometimes replace memmove with memcpy. Valgrind may report a false positive.
+  Memcheck:Overlap
+  fun:__memcpy_chk
+  fun:memmove
+  ...
+}
+{
+  Requiring a file will add it to the loaded features, which may be reported as a leak.
+  Memcheck:Leak
+  ...
+  fun:require_internal
+  ...
+}
+{
+  Remove this after Ruby 2.7.7, 3.0.5, 3.1.3 are relased. See: https://github.com/Shopify/ruby_memcheck/issues/6
+  Memcheck:Leak
+  ...
+  fun:stack_chunk_alloc
+  ...
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_memcheck
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Peter Zhu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-04 00:00:00.000000000 Z
+date: 2022-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -148,6 +148,7 @@ files:
 - lib/ruby_memcheck/valgrind_error.rb
 - lib/ruby_memcheck/version.rb
 - ruby_memcheck.gemspec
+- suppressions/ruby.supp
 homepage: https://github.com/peterzhu2118/ruby_memcheck
 licenses:
 - MIT
@@ -168,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Use Valgrind memcheck without going crazy