ruby_memcheck 0.1.2 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa5f0f59617f5220d6870d3d44cae58605b9488c31d03c1c1d027895fafaf83d
-  data.tar.gz: 999a0744c5a3c32ddf1e51d3f31164d13c144afe138fc4793b1930fcf3ec7a9e
+  metadata.gz: 6afc968d17cd1fabb39f254c3f2373534773e42b094345765c058538cc05b208
+  data.tar.gz: fe3603ae51113b37d9e07b38e981c0ddab8e9b5059c8c8a797dbc21f5dd31b30
 SHA512:
-  metadata.gz: f95821f8680a6685deb30e3a3acb8763878a52c76149f922f8a237f36406a0ded80e34dcbf66da29f78112e4fc4a4e3e534a7f6aa019a1df104c9e0d3cc18dbf
-  data.tar.gz: 1d8cd567af6606c87b4222832917417a478e8ab265db59fffbc8ad4cd418bfd6bf06f63170ce537865972232134b503c23a661abdbdbc6b3f64d0ee2c7ca3a44
+  metadata.gz: c4402ac65e791413b6e46abf296d21ca1bcd6277469a743a9f00fbadb3802993746ccdd89064de7171c1a4609c8162c245ef8d08d4314e0d598abb1a7f287585
+  data.tar.gz: '08dfe5c75b6502f563b739d98c8821b3c199fe37dae0f1078158ffc4e43933d18bd508efd7901320c4ad254c4703cbf78ba1de7afe734122acf368d99503e7f7'

data/.rubocop.yml

@@ -2,4 +2,9 @@ inherit_gem:
   rubocop-shopify: rubocop.yml
 
 AllCops:
+  TargetRubyVersion: 2.6
   SuggestExtensions: false
+
+Style/GlobalVars:
+  Exclude:
+    - test/ruby_memcheck/ext/extconf.rb

data/README.md

@@ -9,11 +9,14 @@ This gem provides a sane way to use Valgrind's memcheck on your native extension
     1. [How does it work?](#how-does-it-work)
     1. [Limitations](#limitations)
 1. [Installation](#installation)
-1. [Usage](#usage)
+1. [Setup](#setup)
+1. [Configuration](#configuration)
+1. [Suppression files](#suppression-files)
+1. [License](#license)
 
 ## What is this gem?
 
-Valgrind's memcheck is a great tool to find and debug memory issues (e.g. memory leak, use-after-free, etc.). However, it doesn't work well on Ruby because Ruby does not free all of the memory it allocates during shutdown. This results in Valgrind reporting thousands (or more) false-positives, making it very difficult for Valgrind to actually be useful. This gem solves the problem by using heuristics to filter out false-positives.
+Valgrind's memcheck is a great tool to find and debug memory issues (e.g. memory leak, use-after-free, etc.). However, it doesn't work well on Ruby because Ruby does not free all of the memory it allocates during shutdown. This results in Valgrind reporting thousands (or more) false positives, making it very difficult for Valgrind to actually be useful. This gem solves the problem by using heuristics to filter out false positives.
 
 ### Who should use this gem?
 
@@ -21,11 +24,11 @@ Only gems with native extensions can use this gem. If your gem is written in pla
 
 ### How does it work?
 
-This gem runs Valgrind with the `--xml` option to generate a 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.
+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.
 
 ### Limitations
 
-Because of the aggressive heuristics used to filter out false-positives, there are various limitations of what this gem can detect.
+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. It will not find memory leaks in Ruby. It filters out everything in Ruby.
@@ -38,15 +41,13 @@ Because of the aggressive heuristics used to filter out false-positives, there a
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-```ruby
-gem "ruby_memcheck"
+```
+gem install ruby_memcheck
 ```
 
-## Usage
+## Setup
 
-The easiest way to use this gem is to use it on your test suite using rake.
+The easiest way to use this gem is to use it on your test suite (minitest or RSpec) using rake.
 
 0. Install Valgrind.
 1. In your Rakefile, require this gem.
@@ -54,43 +55,110 @@ The easiest way to use this gem is to use it on your test suite using rake.
     ```ruby
     require "ruby_memcheck"
     ```
+
+    - **For RSpec:** If you're using RSpec, also add the following require.
+
+      ```ruby
+      require "ruby_memcheck/rspec/rake_task"
+      ```
+
 1. Configure the gem by calling `RubyMemcheck.config`. You must pass it your binary name. This is the same value you passed into `create_makefile` in your `extconf.rb` file. Make sure this value is correct or it will filter out almost everything as a false-positive!
 
     ```ruby
     RubyMemcheck.config(binary_name: "your_binary_name")
     ```
-1. Locate your test task(s) in your Rakefile. You can identify it with a call to `Rake::TestTask.new`.
-1. Create a namespace under the test task and create a `RubyMemcheck::TestTask` with the same configuration.
+1. Setup the test task for your test framework.
+    - **minitest**
+    
+      Locate your test task(s) in your Rakefile. You can identify it with a call to `Rake::TestTask.new`.
 
-    For example, if your Rakefile looked like this before:
+      Create a namespace under the test task and create a `RubyMemcheck::TestTask` with the same configuration.
 
-    ```ruby
-    Rake::TestTask.new(test: :compile) do |t|
-      t.libs << "test"
-      t.test_files = FileList["test/unit/**/*_test.rb"]
-    end
-    ```
+      For example, if your Rakefile looked like this before:
 
-    You can change it to look like this:
+      ```ruby
+      Rake::TestTask.new(test: :compile) do |t|
+        t.libs << "test"
+        t.test_files = FileList["test/unit/**/*_test.rb"]
+      end
+      ```
 
-    ```ruby
-    test_config = lambda do |t|
-      t.libs << "test"
-      t.test_files = FileList["test/**/*_test.rb"]
-    end
-    Rake::TestTask.new(test: :compile, &test_config)
-    namespace :test do
-      RubyMemcheck::TestTask.new(valgrind: :compile, &test_config)
-    end
-    ```
-1. In your `test_helper.rb`/`spec_helper.rb` (or whatever file sets up your test suite), add this line:
+      You can change it to look like this:
 
-    ```ruby
-    END { GC.start }
-    ```
+      ```ruby
+      test_config = lambda do |t|
+        t.libs << "test"
+        t.test_files = FileList["test/**/*_test.rb"]
+      end
+      Rake::TestTask.new(test: :compile, &test_config)
+      namespace :test do
+        RubyMemcheck::TestTask.new(valgrind: :compile, &test_config)
+      end
+      ```
+
+    - **RSpec**
+
+      Locate your rake task(s) in your Rakefile. You can identify it with a call to `RSpec::Core::RakeTask.new`.
+
+      Create a namespace under the test task and create a `RubyMemcheck::RSpec::RakeTask` with the same configuration.
+
+      For example, if your Rakefile looked like this before:
+
+      ```ruby
+      RubyMemcheck::RSpec::RakeTask.new(spec: :compile)
+      ```
+
+      You can change it to look like this:
+
+      ```ruby
+      RubyMemcheck::RSpec::RakeTask.new(spec: :compile)
+      namespace :spec do
+        RubyMemcheck::RSpec::RakeTask.new(valgrind: :compile)
+      end
+      ```
+
+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.
+
+## Configuration
+
+When you run `RubyMemcheck.config`, you are creating a default `RubyMemcheck::Configuration`. By default, the Rake tasks for minitest and RSpec will use this configuration. You can also manually pass in a `Configuration` object as the first argument to the constructor of `RubyMemcheck::TestTask` or `RubyMemcheck::RSpec::RakeTask` to use a different `Configuration` object rather than the default one.
+
+`RubyMemcheck::Configuration` accepts a variety of keyword arguments. Here are all the arguments:
+
+- `binary_name`: Required. The binary name of your native extension gem. This is the same value you passed into `create_makefile` in your `extconf.rb` file.
+- `ruby`: Optional. The command to run to invoke Ruby. Defaults to the Ruby that is currently being used.
+- `valgrind`: Optional. The command to run to invoke Valgrind. Defaults to the string `"valgrind"`.
+- `valgrind_options`: Optional. Array of options to pass into Valgrind. This is only present as an escape hatch, so avoid using it. This may be deprecated or removed in future versions.
+- `valgrind_suppressions_dir`: Optional. The string path of the directory that stores suppression files for Valgrind. See the [`Suppression files`](#suppression-files) section for more details. Defaults to `suppressions`.
+- `valgrind_generate_suppressions`: Optional. Whether suppressions should also be outputted along with the errors. the [`Suppression files`](#suppression-files) section for more details. Defaults to `false`.
+- `skipped_ruby_functions`: Optional. Ruby functions that are ignored because they are considered a call back into Ruby. This is only present as an escape hatch, so avoid using it. If you find another Ruby function that is a false positive because it calls back into Ruby, please send a patch into this repo. Otherwise, use a Valgrind suppression file.
+- `valgrind_xml_dir`: Optional. The directory to store temporary XML files for Valgrind. It defaults to a temporary directory. This is present for development debugging, so you shouldn't have to use it.
+- `output_io`: Optional. The `IO` object to output Valgrind errors to. Defaults to standard error.
+
+## Suppression files
+
+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.).
+
+## Success stories
+
+Let's celebrate wins from this gem! If this gem was useful for you, please share your story below too!
 
-    This will ensure that the Garbage Collector is ran before Ruby shuts down. This will reduce the number of false-positives.
-1. You're ready to run your test suite with Valgrind using `rake test:valgrind`! Note that this will take a while to run because Valgrind will make Ruby significantly slower.
+- [`liquid-c`](https://github.com/Shopify/liquid-c):
+  - Found 2 memory leaks: [#157](https://github.com/Shopify/liquid-c/pull/157), [#161](https://github.com/Shopify/liquid-c/pull/161)
+  - Running on CI: [#162](https://github.com/Shopify/liquid-c/pull/162)
+- [`nokogiri`](https://github.com/sparklemotion/nokogiri):
+  - Found 5 memory leaks: [4 in #2345](https://github.com/sparklemotion/nokogiri/pull/2345), [#2347](https://github.com/sparklemotion/nokogiri/pull/2347)
+  - CI is WIP: [#2344](https://github.com/sparklemotion/nokogiri/pull/2344)
+- [`rotoscope`](https://github.com/Shopify/rotoscope):
+  - Found a [memory leak in Ruby TracePoint](https://bugs.ruby-lang.org/issues/18264)
+  - Running on CI: [#89](https://github.com/Shopify/rotoscope/pull/89)
+- [`protobuf`](https://github.com/protocolbuffers/protobuf):
+  - Found 1 memory leak: [#9150](https://github.com/protocolbuffers/protobuf/pull/9150)
+- [`gRPC`](https://github.com/grpc/grpc):
+  - Found 1 memory leak: [#27900](https://github.com/grpc/grpc/pull/27900)
 
 ## License
 

data/lib/ruby_memcheck/configuration.rb

@@ -6,88 +6,91 @@ module RubyMemcheck
     DEFAULT_VALGRIND_OPTIONS = [
       "--num-callers=50",
       "--error-limit=no",
+      "--trace-children=yes",
       "--undef-value-errors=no",
       "--leak-check=full",
       "--show-leak-kinds=definite",
     ].freeze
+    DEFAULT_VALGRIND_SUPPRESSIONS_DIR = "suppressions"
     DEFAULT_SKIPPED_RUBY_FUNCTIONS = [
+      /\Aeval_string_with_cref\z/,
+      /\Arb_add_method_cfunc\z/,
       /\Arb_check_funcall/,
+      /\Arb_class_boot\z/, # Called for all the different ways to create a Class
       /\Arb_enc_raise\z/,
       /\Arb_exc_raise\z/,
+      /\Arb_extend_object\z/,
       /\Arb_funcall/,
+      /\Arb_intern/,
       /\Arb_ivar_set\z/,
+      /\Arb_module_new\z/,
       /\Arb_raise\z/,
       /\Arb_rescue/,
       /\Arb_respond_to\z/,
+      /\Arb_thread_create\z/, # Threads are relased to a cache, so they may be reported as a leak
       /\Arb_yield/,
     ].freeze
 
-    attr_reader :binary_name, :ruby, :valgrind_options, :valgrind,
-      :skipped_ruby_functions, :valgrind_xml_file, :output_io
+    attr_reader :binary_name, :ruby, :valgrind, :valgrind_options, :valgrind_suppressions_dir,
+      :valgrind_generate_suppressions, :skipped_ruby_functions, :valgrind_xml_dir, :output_io
+    alias_method :valgrind_generate_suppressions?, :valgrind_generate_suppressions
 
     def initialize(
       binary_name:,
       ruby: FileUtils::RUBY,
       valgrind: DEFAULT_VALGRIND,
       valgrind_options: DEFAULT_VALGRIND_OPTIONS,
+      valgrind_suppressions_dir: DEFAULT_VALGRIND_SUPPRESSIONS_DIR,
+      valgrind_generate_suppressions: false,
       skipped_ruby_functions: DEFAULT_SKIPPED_RUBY_FUNCTIONS,
-      valgrind_xml_file: Tempfile.new,
+      valgrind_xml_dir: Dir.mktmpdir,
       output_io: $stderr
     )
       @binary_name = binary_name
       @ruby = ruby
       @valgrind = valgrind
       @valgrind_options = valgrind_options
+      @valgrind_suppressions_dir = File.expand_path(valgrind_suppressions_dir)
+      @valgrind_generate_suppressions = valgrind_generate_suppressions
       @skipped_ruby_functions = skipped_ruby_functions
       @output_io = output_io
 
-      if valgrind_xml_file
-        @valgrind_xml_file = valgrind_xml_file
+      if valgrind_xml_dir
+        valgrind_xml_dir = File.expand_path(valgrind_xml_dir)
+        FileUtils.mkdir_p(valgrind_xml_dir)
+        @valgrind_xml_dir = valgrind_xml_dir
         @valgrind_options += [
           "--xml=yes",
-          "--xml-file=#{valgrind_xml_file.path}",
+          # %p will be replaced with the PID
+          # This prevents forking and shelling out from generating a corrupted XML
+          # See --log-file from https://valgrind.org/docs/manual/manual-core.html
+          "--xml-file=#{File.join(valgrind_xml_dir, "%p.out")}",
         ]
       end
     end
 
     def command(*args)
-      "#{valgrind} #{valgrind_options.join(" ")} #{ruby} #{args.join(" ")}"
+      [
+        valgrind,
+        valgrind_options,
+        get_valgrind_suppression_files(valgrind_suppressions_dir).map { |f| "--suppressions=#{f}" },
+        valgrind_generate_suppressions ? "--gen-suppressions=all" : "",
+        ruby,
+        args,
+      ].flatten.join(" ")
     end
 
-    def skip_stack?(stack)
-      in_binary = false
+    private
 
-      stack.frames.each do |frame|
-        fn = frame.fn
+    def get_valgrind_suppression_files(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
 
-        if frame_in_ruby?(frame) # in ruby
-          unless in_binary
-            # Skip this stack because it was called from Ruby
-            return true if skipped_ruby_functions.any? { |r| r.match?(fn) }
-          end
-        elsif frame_in_binary?(frame) # in binary
-          in_binary = true
-
-          # Skip the Init function
-          return true if fn == "Init_#{binary_name}"
-        end
-      end
-
-      !in_binary
-    end
-
-    def frame_in_ruby?(frame)
-      frame.obj == ruby ||
-        # Hack to fix Ruby built with --enabled-shared
-        File.basename(frame.obj) == "libruby.so.#{RUBY_VERSION}"
-    end
-
-    def frame_in_binary?(frame)
-      if frame.obj
-        File.basename(frame.obj, ".*") == binary_name
-      else
-        false
-      end
+      versions.map do |version|
+        Dir[File.join(dir, "#{binary_name}_#{version}.supp")]
+      end.flatten
     end
   end
 end

data/lib/ruby_memcheck/frame.rb

@@ -2,17 +2,29 @@
 
 module RubyMemcheck
   class Frame
-    attr_reader :fn, :obj, :file, :line, :in_binary
-    alias_method :in_binary?, :in_binary
+    attr_reader :configuration, :fn, :obj, :file, :line
 
     def initialize(configuration, frame_xml)
+      @configuration = configuration
       @fn = frame_xml.at_xpath("fn")&.content
       @obj = frame_xml.at_xpath("obj")&.content
       # file and line may not be available
       @file = frame_xml.at_xpath("file")&.content
       @line = frame_xml.at_xpath("line")&.content
+    end
+
+    def in_ruby?
+      obj == configuration.ruby ||
+        # Hack to fix Ruby built with --enabled-shared
+        File.basename(obj) == "libruby.so.#{RUBY_VERSION}"
+    end
 
-      @in_binary = configuration.frame_in_binary?(self)
+    def in_binary?
+      if obj
+        File.basename(obj, ".*") == configuration.binary_name
+      else
+        false
+      end
     end
 
     def to_s

data/lib/ruby_memcheck/rspec/rake_task.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+module RubyMemcheck
+  module RSpec
+    class RakeTask < ::RSpec::Core::RakeTask
+      include TestTaskReporter
+
+      attr_reader :configuration
+
+      def initialize(*args)
+        @configuration =
+          if !args.empty? && args[0].is_a?(Configuration)
+            args.shift
+          else
+            RubyMemcheck.default_configuration
+          end
+
+        super
+      end
+
+      def run_task(verbose)
+        error = nil
+
+        begin
+          # RSpec::Core::RakeTask#run_task calls Kernel.exit on failure
+          super
+        rescue SystemExit => e
+          error = e
+        end
+
+        report_valgrind_errors
+
+        raise error if error
+      end
+
+      private
+
+      def spec_command
+        # First part of command is Ruby
+        args = super.split(" ")[1..]
+
+        configuration.command(args)
+      end
+    end
+  end
+end

data/lib/ruby_memcheck/stack.rb

@@ -2,10 +2,38 @@
 
 module RubyMemcheck
   class Stack
-    attr_reader :frames
+    attr_reader :configuration, :frames
 
     def initialize(configuration, stack_xml)
+      @configuration = configuration
       @frames = stack_xml.xpath("frame").map { |frame| Frame.new(configuration, frame) }
     end
+
+    def skip?
+      in_binary = false
+
+      frames.each do |frame|
+        fn = frame.fn
+
+        if frame.in_ruby?
+          # If a stack from from the binary was encountered first, then this
+          # memory leak did not occur from Ruby
+          unless in_binary
+            # Skip this stack because it was called from Ruby
+            return true if configuration.skipped_ruby_functions.any? { |r| r.match?(fn) }
+          end
+        elsif frame.in_binary?
+          in_binary = true
+
+          # Skip the Init function because it is only ever called once, so
+          # leaks in it cannot cause memory bloat
+          return true if fn == "Init_#{configuration.binary_name}"
+        end
+      end
+
+      # Skip if the stack was never in the binary because it is very likely
+      # not a leak in the native gem
+      !in_binary
+    end
   end
 end

data/lib/ruby_memcheck/suppression.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyMemcheck
+  class Suppression
+    attr_reader :root
+
+    def initialize(configuration, suppression_node)
+      @root = suppression_node
+    end
+
+    def to_s
+      str = StringIO.new
+      str << "{\n"
+      str << "  #{root.at_xpath("sname").content}\n"
+      str << "  #{root.at_xpath("skind").content}\n"
+      root.xpath("./sframe/fun | ./sframe/obj").each do |frame|
+        str << "  #{frame.name}:#{frame.content}\n"
+      end
+      str << "}\n"
+      str.string
+    end
+  end
+end

data/lib/ruby_memcheck/test_task.rb

@@ -2,9 +2,9 @@
 
 module RubyMemcheck
   class TestTask < Rake::TestTask
-    VALGRIND_REPORT_MSG = "Valgrind reported errors (e.g. memory leak or use-after-free)"
+    include TestTaskReporter
 
-    attr_reader :configuration, :errors
+    attr_reader :configuration
 
     def initialize(*args)
       @configuration =
@@ -20,36 +20,10 @@ module RubyMemcheck
     def ruby(*args, **options, &block)
       command = configuration.command(args)
       sh(command, **options) do |ok, res|
-        if ok && configuration.valgrind_xml_file
-          parse_valgrind_output
-          unless errors.empty?
-            output_valgrind_errors
-            raise VALGRIND_REPORT_MSG
-          end
-        end
+        report_valgrind_errors
 
         yield ok, res if block_given?
       end
     end
-
-    private
-
-    def parse_valgrind_output
-      @errors = []
-
-      xml = Nokogiri::XML(configuration.valgrind_xml_file.read)
-      xml.xpath("/valgrindoutput/error").each do |error_xml|
-        error = ValgrindError.new(configuration, error_xml)
-        next if error.skip?
-        @errors << error
-      end
-    end
-
-    def output_valgrind_errors
-      @errors.each do |error|
-        configuration.output_io.puts error
-        configuration.output_io.puts
-      end
-    end
   end
 end

data/lib/ruby_memcheck/test_task_reporter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyMemcheck
+  module TestTaskReporter
+    VALGRIND_REPORT_MSG = "Valgrind reported errors (e.g. memory leak or use-after-free)"
+
+    attr_reader :errors
+
+    private
+
+    def report_valgrind_errors
+      if configuration.valgrind_xml_dir
+        xml_files = valgrind_xml_files
+        parse_valgrind_output(xml_files)
+        remove_valgrind_xml_files(xml_files)
+
+        unless errors.empty?
+          output_valgrind_errors
+          raise VALGRIND_REPORT_MSG
+        end
+      end
+    end
+
+    def valgrind_xml_files
+      Dir[File.join(configuration.valgrind_xml_dir, "*")]
+    end
+
+    def parse_valgrind_output(xml_files)
+      require "nokogiri"
+
+      @errors = []
+
+      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
+    end
+
+    def remove_valgrind_xml_files(xml_files)
+      xml_files.each do |file|
+        File.delete(file)
+      end
+    end
+
+    def output_valgrind_errors
+      @errors.each do |error|
+        configuration.output_io.puts error
+        configuration.output_io.puts
+      end
+    end
+  end
+end

data/lib/ruby_memcheck/valgrind_error.rb

@@ -2,7 +2,10 @@
 
 module RubyMemcheck
   class ValgrindError
-    attr_reader :kind, :msg, :stack
+    SUPPRESSION_NOT_CONFIGURED_ERROR_MSG =
+      "Please enable suppressions by configuring with valgrind_generate_suppressions set to true"
+
+    attr_reader :kind, :msg, :stack, :suppression
 
     def initialize(configuration, error)
       @kind = error.at_xpath("kind").content
@@ -14,14 +17,17 @@ module RubyMemcheck
         end
       @stack = Stack.new(configuration, error.at_xpath("stack"))
       @configuration = configuration
+
+      suppression_node = error.at_xpath("suppression")
+      if configuration.valgrind_generate_suppressions?
+        @suppression = Suppression.new(configuration, suppression_node)
+      elsif suppression_node
+        raise SUPPRESSION_NOT_CONFIGURED_ERROR_MSG
+      end
     end
 
     def skip?
-      if should_filter?
-        @configuration.skip_stack?(stack)
-      else
-        false
-      end
+      should_filter? && stack.skip?
     end
 
     def to_s
@@ -34,6 +40,7 @@ module RubyMemcheck
           "  #{frame}\n"
         end
       end
+      str << suppression.to_s if suppression
       str.string
     end
 

data/lib/ruby_memcheck/version.rb

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

data/lib/ruby_memcheck.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
 require "tempfile"
-require "nokogiri"
 require "rake/testtask"
 
 require "ruby_memcheck/configuration"
 require "ruby_memcheck/frame"
 require "ruby_memcheck/stack"
+require "ruby_memcheck/test_task_reporter"
 require "ruby_memcheck/test_task"
 require "ruby_memcheck/valgrind_error"
+require "ruby_memcheck/suppression"
 require "ruby_memcheck/version"
 
 module RubyMemcheck

data/ruby_memcheck.gemspec

@@ -27,8 +27,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency("nokogiri")
 
   spec.add_development_dependency("minitest", "~> 5.0")
+  spec.add_development_dependency("minitest-parallel_fork", "~> 1.2")
   spec.add_development_dependency("rake", "~> 13.0")
   spec.add_development_dependency("rake-compiler", "~> 1.1")
+  spec.add_development_dependency("rspec-core")
   spec.add_development_dependency("rubocop", "~> 1.22")
   spec.add_development_dependency("rubocop-shopify", "~> 2.3")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_memcheck
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.0.1
 platform: ruby
 authors:
 - Peter Zhu
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-18 00:00:00.000000000 Z
+date: 2021-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-parallel_fork
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  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'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +122,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
-description:
+description: 
 email:
 - peter@peterzhu.ca
 executables: []
@@ -112,8 +140,11 @@ files:
 - lib/ruby_memcheck.rb
 - lib/ruby_memcheck/configuration.rb
 - lib/ruby_memcheck/frame.rb
+- lib/ruby_memcheck/rspec/rake_task.rb
 - lib/ruby_memcheck/stack.rb
+- lib/ruby_memcheck/suppression.rb
 - lib/ruby_memcheck/test_task.rb
+- lib/ruby_memcheck/test_task_reporter.rb
 - lib/ruby_memcheck/valgrind_error.rb
 - lib/ruby_memcheck/version.rb
 - ruby_memcheck.gemspec
@@ -122,7 +153,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/peterzhu2118/ruby_memcheck
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -137,8 +168,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key:
+rubygems_version: 3.2.22
+signing_key: 
 specification_version: 4
 summary: Use Valgrind memcheck without going crazy
 test_files: []