appmap 0.33.0 → 0.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae23c62b9a3f01cc3b7680706746d2f51c94c3a776978a8ee2d4e0e8501fca01
-  data.tar.gz: 4aa33af19ed0c31b826f8cffa75e147e2781fe93ed39353ace29cede8a7882b9
+  metadata.gz: 47030df4910179ac636b8a2c4c3c29c25225deb1b9cbce851264d1e2ae8dacf1
+  data.tar.gz: 84bc3de36a1f7700fe32128c40f8d2bf6d698208689e856fd2bc696c38be6500
 SHA512:
-  metadata.gz: 04a3c1bee70c02c96c1b71d5153a6ed44d668d6fc69d6da77cd6201364ede609bee93604f4ace391ddb38f8259841d6b334fdbe9051f1667d41cf3383281fe58
-  data.tar.gz: c60d868b2c1fa9c1e8742856dd7f946f5bf1284cab01a4478708c1582add5ca8fd16002e150d8a2cd897819edb661a9082cb01ec3e9879686d85d49b341d4ba8
+  metadata.gz: 98d8933599f9cdb39d2ab9d69d1c11c7f06972603c30b5d79b3c57dc2ec246aec2c432da4835bcab805d49ec17e757fc0377d583908c6894380e951071b2d797
+  data.tar.gz: eefe2496acc6be7ebfe20eee2ab9ed0e708658a039c196757dd00ca18351e0425d3a6d1f0599cca37bd4a2c786469d61fdc7ad0e50a56d9223360204e2bc4206

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.34.0
+
+* Records builtin security and I/O methods from `OpenSSL`, `Net`, and `IO`.
+
 # v0.33.0
 
 * Added command `AppMap.open` to open an AppMap in the browser.

data/lib/appmap/class_map.rb

@@ -61,7 +61,7 @@ module AppMap
             location: location,
             static: static,
             labels: labels
-          }.delete_if {|k,v| v.nil?}
+          }.delete_if { |k,v| v.nil? || v == [] }
         end
       end
     end
@@ -100,11 +100,16 @@ module AppMap
           static: static
         }
         location = method.source_location
-        if location
-          location_file, lineno = location
-          location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
-          function_info[:location] = [ location_file, lineno ].join(':')
-        end
+
+        function_info[:location] = \
+          if location
+            location_file, lineno = location
+            location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
+            [ location_file, lineno ].join(':')
+          else
+            [ method.defined_class, static ? '.' : '#', method.name ].join
+          end
+
         function_info[:labels] = package.labels if package.labels
         object_infos << function_info
 

data/lib/appmap/config.rb

@@ -1,31 +1,54 @@
 # frozen_string_literal: true
 
 module AppMap
-  Package = Struct.new(:path, :package_name, :exclude, :labels) do
-    def initialize(path, package_name, exclude, labels = nil)
-      super
+  class Config
+    Package = Struct.new(:path, :package_name, :exclude, :labels) do
+      def initialize(path, package_name: nil, exclude: [], labels: [])
+        super path, package_name, exclude, labels
+      end
+  
+      def to_h
+        {
+          path: path,
+          package_name: package_name,
+          exclude: exclude.blank? ? nil : exclude,
+          labels: labels.blank? ? nil : labels
+        }.compact
+      end
     end
 
-    def to_h
-      {
-        path: path,
-        package_name: package_name,
-        exclude: exclude.blank? ? nil : exclude,
-        labels: labels.blank? ? nil : labels
-      }.compact
+    Hook = Struct.new(:method_names, :package) do
     end
-  end
 
-  class Config
+    OPENSSL_PACKAGE = Package.new('openssl', package_name: 'openssl', labels: %w[security crypto])
+
     # Methods that should always be hooked, with their containing
     # package and labels that should be applied to them.
     HOOKED_METHODS = {
-      'ActiveSupport::SecurityUtils' => {
-        secure_compare: Package.new('active_support', nil, nil, ['security'])
-      }
-    }
+      'ActiveSupport::SecurityUtils' => Hook.new(:secure_compare, Package.new('active_support', package_name: 'active_support', labels: %w[security crypto]))
+    }.freeze
+
+    BUILTIN_METHODS = {
+      'OpenSSL::PKey::PKey' => Hook.new(:sign, OPENSSL_PACKAGE),
+      'Digest::Instance' => Hook.new(:digest, OPENSSL_PACKAGE),
+      'OpenSSL::X509::Request' => Hook.new(%i[sign verify], OPENSSL_PACKAGE),
+      'OpenSSL::PKCS5' => Hook.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGE),
+      'OpenSSL::Cipher' => Hook.new(%i[encrypt decrypt final], OPENSSL_PACKAGE),
+      'OpenSSL::X509::Certificate' => Hook.new(:sign, OPENSSL_PACKAGE),
+      'Logger' => Hook.new(:add, Package.new('logger', labels: %w[log io])),
+      'Net::HTTP' => Hook.new(:request, Package.new('net/http', package_name: 'net/http', labels: %w[http io])),
+      'Net::SMTP' => Hook.new(:send, Package.new('net/smtp', package_name: 'net/smtp', labels: %w[smtp email io])),
+      'Net::POP3' => Hook.new(:mails, Package.new('net/pop3', package_name: 'net/pop', labels: %w[pop pop3 email io])),
+      'Net::IMAP' => Hook.new(:send_command, Package.new('net/imap', package_name: 'net/imap', labels: %w[imap email io])),
+      'IO' => Hook.new(%i[read write open close], Package.new('io', labels: %w[io])),
+      'Marshal' => Hook.new(%i[dump load], Package.new('marshal', labels: %w[serialization marshal])),
+      'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.new('yaml', package_name: 'psych', labels: %w[serialization yaml])),
+      'JSON::Ext::Parser' => Hook.new(:parse, Package.new('json', package_name: 'json', labels: %w[serialization json])),
+      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.new('json', package_name: 'json', labels: %w[serialization json]))
+    }.freeze
 
     attr_reader :name, :packages
+
     def initialize(name, packages = [])
       @name = name
       @packages = packages
@@ -41,7 +64,7 @@ module AppMap
       # Loads configuration from a Hash.
       def load(config_data)
         packages = (config_data['packages'] || []).map do |package|
-          Package.new(package['path'], nil, package['exclude'] || [])
+          Package.new(package['path'], exclude: package['exclude'] || [])
         end
         Config.new config_data['name'], packages
       end
@@ -55,9 +78,9 @@ module AppMap
     end
 
     def package_for_method(method)
-      defined_class, _, method_name = Hook.qualify_method_name(method)
-      hooked_method = find_hooked_method(defined_class, method_name)
-      return hooked_method if hooked_method
+      defined_class, _, method_name = ::AppMap::Hook.qualify_method_name(method)
+      package = find_package(defined_class, method_name)
+      return package if package
 
       location = method.source_location
       location_file, = location
@@ -75,15 +98,18 @@ module AppMap
     end
 
     def always_hook?(defined_class, method_name)
-      !!find_hooked_method(defined_class, method_name)
+      !!find_package(defined_class, method_name)
     end
 
-    def find_hooked_method(defined_class, method_name)
-      find_hooked_class(defined_class)[method_name]
+    def find_package(defined_class, method_name)
+      hook = find_hook(defined_class)
+      return nil unless hook
+
+      Array(hook.method_names).include?(method_name) ? hook.package : nil      
     end
 
-    def find_hooked_class(defined_class)
-      HOOKED_METHODS[defined_class] || {}
+    def find_hook(defined_class)
+      HOOKED_METHODS[defined_class] || BUILTIN_METHODS[defined_class]
     end
   end
 end

data/lib/appmap/hook.rb

@@ -7,6 +7,12 @@ module AppMap
     LOG = (ENV['DEBUG'] == 'true')
 
     class << self
+      def lock_builtins
+        return if @builtins_hooked
+
+        @builtins_hooked = true
+      end
+
       # Return the class, separator ('.' or '#'), and method name for
       # the given method.
       def qualify_method_name(method)
@@ -39,6 +45,8 @@ module AppMap
     def enable &block
       require 'appmap/hook/method'
 
+      hook_builtins
+
       tp = TracePoint.new(:end) do |trace_point|
         cls = trace_point.self
 
@@ -47,8 +55,6 @@ module AppMap
 
         hook = lambda do |hook_cls|
           lambda do |method_id|
-            next if method_id.to_s =~ /_hooked_by_appmap$/
-
             method = hook_cls.public_instance_method(method_id)
             hook_method = Hook::Method.new(hook_cls, method)
 
@@ -76,5 +82,35 @@ module AppMap
 
       tp.enable(&block)
     end
+
+    def hook_builtins
+      return unless self.class.lock_builtins
+
+      class_from_string = lambda do |fq_class|
+        fq_class.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      end
+
+      Config::BUILTIN_METHODS.each do |class_name, hook|
+        require hook.package.package_name if hook.package.package_name
+        Array(hook.method_names).each do |method_name|
+          method_name = method_name.to_sym
+          cls = class_from_string.(class_name)
+          method = \
+            begin
+              cls.instance_method(method_name)
+            rescue NameError
+              cls.method(method_name) rescue nil
+            end
+
+          if method
+            Hook::Method.new(cls, method).activate
+          else
+            warn "Method #{method_name} not found on #{cls.name}" 
+          end
+        end
+      end
+    end
   end
 end

data/lib/appmap/rspec.rb

@@ -154,7 +154,7 @@ module AppMap
         end
 
         labels = labels.map(&:to_s).map(&:strip).reject(&:blank?).map(&:downcase).uniq
-        description.reject!(&:nil?).reject(&:blank?)
+        description.reject!(&:nil?).reject!(&:blank?)
         default_description = description.last
         description.reverse!
 

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.33.0'
+  VERSION = '0.34.0'
 
   APPMAP_FORMAT_VERSION = '1.2'
 end

data/spec/hook_spec.rb

@@ -27,7 +27,7 @@ describe 'AppMap class Hooking', docker: false do
 
   def invoke_test_file(file, setup: nil, &block)
     AppMap.configuration = nil
-    package = AppMap::Package.new(file, nil, [])
+    package = AppMap::Config::Package.new(file)
     config = AppMap::Config.new('hook_spec', [ package ])
     AppMap.configuration = config
     tracer = nil
@@ -51,7 +51,8 @@ describe 'AppMap class Hooking', docker: false do
     config, tracer = invoke_test_file(file, setup: setup, &block)
 
     events = collect_events(tracer)
-    expect(Diffy::Diff.new(events, events_yaml).to_s).to eq('')
+
+    expect(Diffy::Diff.new(events_yaml, events).to_s).to eq('')
 
     [ config, tracer ]
   end
@@ -99,7 +100,7 @@ describe 'AppMap class Hooking', docker: false do
       InstanceMethod.new.say_default
     end
     class_map = AppMap.class_map(tracer.event_methods).to_yaml
-    expect(Diffy::Diff.new(class_map, <<~YAML).to_s).to eq('')
+    expect(Diffy::Diff.new(<<~YAML, class_map).to_s).to eq('')
     ---
     - :name: spec/fixtures/hook/instance_method.rb
       :type: package
@@ -481,12 +482,52 @@ describe 'AppMap class Hooking', docker: false do
           :class: Module
           :value: ActiveSupport::SecurityUtils
       - :id: 3
+        :event: :call
+        :defined_class: Digest::Instance
+        :method_id: digest
+        :path: Digest::Instance#digest
+        :static: false
+        :parameters:
+        - :name: arg
+          :class: String
+          :value: string
+          :kind: :rest
+        :receiver:
+          :class: Digest::SHA256
+          :value: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+      - :id: 4
+        :event: :return
+        :parent_id: 3
+        :return_value:
+          :class: String
+          :value: "G2__)__qc____X____3_].\\x02y__.___/_"
+      - :id: 5
+        :event: :call
+        :defined_class: Digest::Instance
+        :method_id: digest
+        :path: Digest::Instance#digest
+        :static: false
+        :parameters:
+        - :name: arg
+          :class: String
+          :value: string
+          :kind: :rest
+        :receiver:
+          :class: Digest::SHA256
+          :value: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+      - :id: 6
+        :event: :return
+        :parent_id: 5
+        :return_value:
+          :class: String
+          :value: "G2__)__qc____X____3_].\\x02y__.___/_"
+      - :id: 7
         :event: :return
         :parent_id: 2
         :return_value:
           :class: TrueClass
           :value: 'true'
-      - :id: 4
+      - :id: 8
         :event: :return
         :parent_id: 1
         :return_value:
@@ -527,6 +568,23 @@ describe 'AppMap class Hooking', docker: false do
               :static: true
               :labels:
               - security
+              - crypto
+      - :name: openssl
+        :type: package
+        :children:
+        - :name: Digest
+          :type: class
+          :children:
+          - :name: Instance
+            :type: class
+            :children:
+            - :name: digest
+              :type: function
+              :location: Digest::Instance#digest
+              :static: false
+              :labels:
+              - security
+              - crypto
       YAML
 
       config, tracer = invoke_test_file 'spec/fixtures/hook/compare.rb' do
@@ -538,7 +596,7 @@ describe 'AppMap class Hooking', docker: false do
       expect(entry[:name]).to eq('secure_compare')
       spec = Gem::Specification.find_by_name('activesupport')
       entry[:location].gsub!(spec.base_dir + '/', '')
-      expect(Diffy::Diff.new(cm.to_yaml, classmap_yaml).to_s).to eq('')
+      expect(Diffy::Diff.new(classmap_yaml, cm.to_yaml).to_s).to eq('')
     end
   end
 end

data/test/cli_test.rb

@@ -56,10 +56,12 @@ class CLITest < Minitest::Test
     Class frequency:
     ----------------
     1	Main
+    1	IO
 
     Method frequency:
     ----------------
     1	Main.say_hello
+    1	IO#write
     OUTPUT
   end
 
@@ -80,12 +82,20 @@ class CLITest < Minitest::Test
         {
           "name": "Main",
           "count": 1
+        },
+        {
+          "name": "IO",
+          "count": 1
         }
       ],
       "method_frequency": [
         {
           "name": "Main.say_hello",
           "count": 1
+        },
+        {
+          "name": "IO#write",
+          "count": 1
         }
       ]
     }

data/test/fixtures/openssl_recorder/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'appmap', git: 'applandinc/appmap-ruby', branch: `git rev-parse --abbrev-ref HEAD`.strip

data/test/fixtures/openssl_recorder/appmap.yml

@@ -0,0 +1,3 @@
+name: openssl_recorder
+packages:
+  - path: lib

data/test/fixtures/openssl_recorder/lib/openssl_cert_sign.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# From the manual page https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL.html
+
+require 'openssl'
+
+module Example
+  def Example.sign
+    ca_key = OpenSSL::PKey::RSA.new 2048
+    pass_phrase = 'my secure pass phrase goes here'
+
+    cipher = OpenSSL::Cipher.new 'AES-256-CBC'
+
+    open 'tmp/ca_key.pem', 'w', 0644 do |io|
+      io.write ca_key.export(cipher, pass_phrase)
+    end
+
+    ca_name = OpenSSL::X509::Name.parse '/CN=ca/DC=example'
+
+    ca_cert = OpenSSL::X509::Certificate.new
+    ca_cert.serial = 0
+    ca_cert.version = 2
+    ca_cert.not_before = Time.now
+    ca_cert.not_after = Time.now + 86400
+
+    ca_cert.public_key = ca_key.public_key
+    ca_cert.subject = ca_name
+    ca_cert.issuer = ca_name
+
+    extension_factory = OpenSSL::X509::ExtensionFactory.new
+    extension_factory.subject_certificate = ca_cert
+    extension_factory.issuer_certificate = ca_cert
+
+    ca_cert.add_extension    extension_factory.create_extension('subjectKeyIdentifier', 'hash')
+    ca_cert.add_extension    extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
+
+    ca_cert.add_extension    extension_factory.create_extension(
+      'keyUsage', 'cRLSign,keyCertSign', true)
+
+    ca_cert.sign ca_key, OpenSSL::Digest::SHA1.new
+
+    open 'tmp/ca_cert.pem', 'w' do |io|
+      io.write ca_cert.to_pem
+    end
+
+    csr = OpenSSL::X509::Request.new
+    csr.version = 0
+    csr.subject = OpenSSL::X509::Name.new([ ['CN', 'the name to sign', OpenSSL::ASN1::UTF8STRING] ])
+    csr.public_key = ca_key.public_key
+    csr.sign ca_key, OpenSSL::Digest::SHA1.new
+
+    open 'tmp/csr.pem', 'w' do |io|
+      io.write csr.to_pem
+    end
+
+    csr = OpenSSL::X509::Request.new File.read 'tmp/csr.pem'
+
+    raise 'CSR can not be verified' unless csr.verify csr.public_key
+
+    csr_cert = OpenSSL::X509::Certificate.new
+    csr_cert.serial = 0
+    csr_cert.version = 2
+    csr_cert.not_before = Time.now
+    csr_cert.not_after = Time.now + 600
+
+    csr_cert.subject = csr.subject
+    csr_cert.public_key = csr.public_key
+    csr_cert.issuer = ca_cert.subject
+
+    extension_factory = OpenSSL::X509::ExtensionFactory.new
+    extension_factory.subject_certificate = csr_cert
+    extension_factory.issuer_certificate = ca_cert
+
+    csr_cert.add_extension    extension_factory.create_extension('basicConstraints', 'CA:FALSE')
+
+    csr_cert.add_extension    extension_factory.create_extension(
+        'keyUsage', 'keyEncipherment,dataEncipherment,digitalSignature')
+
+    csr_cert.add_extension    extension_factory.create_extension('subjectKeyIdentifier', 'hash')
+
+    csr_cert.sign ca_key, OpenSSL::Digest::SHA1.new
+
+    'tmp/csr_cert.pem'.tap do |fname|
+      open fname, 'w' do |io|
+        io.write csr_cert.to_pem
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  cert_file = Example.sign
+  puts "Wrote cert file #{cert_file}"
+end

data/test/fixtures/openssl_recorder/lib/openssl_encrypt.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# From the manual page https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL.html
+
+require 'openssl'
+
+module Example
+  def Example.encrypt
+    cipher = OpenSSL::Cipher.new 'AES-256-CBC'
+    cipher.encrypt
+    iv = cipher.random_iv
+
+    pwd = 'some hopefully not to easily guessable password'
+    salt = OpenSSL::Random.random_bytes 16
+    iter = 20000
+    key_len = cipher.key_len
+    digest = OpenSSL::Digest::SHA256.new
+
+    key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest)
+    cipher.key = key
+
+    document = 'the document'
+
+    encrypted = cipher.update document
+    encrypted << cipher.final
+    encrypted
+  end
+end
+
+if __FILE__ == $0
+  ciphertext = Example.encrypt
+  require 'base64'
+  puts "Computed ciphertext #{Base64.urlsafe_encode64(ciphertext)}"
+end

data/test/fixtures/openssl_recorder/lib/openssl_key_sign.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# From the manual page https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL.html
+
+require 'appmap'
+require 'openssl'
+require 'openssl/digest'
+
+module Example
+  def Example.sign
+    key = OpenSSL::PKey::RSA.new 2048
+
+    document = 'the document'
+
+    digest = OpenSSL::Digest::SHA256.new
+    key.sign digest, document
+  end
+end
+
+if __FILE__ == $0
+  appmap = AppMap.record do
+    Example.sign
+    puts 'Computed signature'
+  end
+  appmap['metadata'] = [ 'recorder' => __FILE__ ]
+
+  File.write('appmap.json', JSON.generate(appmap))
+end

data/test/openssl_test.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'English'
+
+class OpenSSLTest < Minitest::Test
+  def perform_test(test_name)
+    Bundler.with_clean_env do
+      Dir.chdir 'test/fixtures/openssl_recorder' do
+        FileUtils.rm_rf 'tmp'
+        system 'bundle config --local local.appmap ../../..'
+        system 'bundle'
+        system({ 'APPMAP' => 'true', 'DEBUG' => 'true' }, %(bundle exec ruby lib/openssl_#{test_name}.rb))
+
+        yield
+      end
+    end
+  end
+
+  def test_key_sign
+    perform_test 'key_sign' do
+      appmap_file = 'appmap.json'
+
+      assert File.file?(appmap_file), 'appmap output file does not exist'
+      appmap = JSON.parse(File.read(appmap_file))
+      assert_equal AppMap::APPMAP_FORMAT_VERSION, appmap['version']
+      assert_equal [ { 'recorder' => 'lib/openssl_key_sign.rb' } ], appmap['metadata']
+      assert_equal JSON.parse(<<~JSON), appmap['classMap']
+      [
+        {
+          "name": "lib",
+          "type": "package",
+          "children": [
+            {
+              "name": "Example",
+              "type": "class",
+              "children": [
+                {
+                  "name": "sign",
+                  "type": "function",
+                  "location": "lib/openssl_key_sign.rb:10",
+                  "static": true
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "openssl",
+          "type": "package",
+          "children": [
+            {
+              "name": "OpenSSL",
+              "type": "class",
+              "children": [
+                {
+                  "name": "PKey",
+                  "type": "class",
+                  "children": [
+                    {
+                      "name": "PKey",
+                      "type": "class",
+                      "children": [
+                        {
+                          "name": "sign",
+                          "type": "function",
+                          "location": "OpenSSL::PKey::PKey#sign",
+                          "static": false,
+                          "labels": [
+                            "security",
+                            "crypto"
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "io",
+          "type": "package",
+          "children": [
+            {
+              "name": "IO",
+              "type": "class",
+              "children": [
+                {
+                  "name": "write",
+                  "type": "function",
+                  "location": "IO#write",
+                  "static": false,
+                  "labels": [
+                    "io"
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+      JSON
+      sanitized_events = appmap['events'].map(&:deep_symbolize_keys).map(&AppMap::Util.method(:sanitize_event)).map do |event|
+        delete_value = ->(obj) { (obj || {}).delete(:value) }
+        delete_value.call(event[:receiver])
+        delete_value.call(event[:return_value])
+        event
+      end
+
+      diff = Diffy::Diff.new(<<~JSON.strip, JSON.pretty_generate(sanitized_events).strip)
+      [
+        {
+          "id": 1,
+          "event": "call",
+          "defined_class": "Example",
+          "method_id": "sign",
+          "path": "lib/openssl_key_sign.rb",
+          "lineno": 10,
+          "static": true,
+          "parameters": [
+      
+          ],
+          "receiver": {
+            "class": "Module"
+          }
+        },
+        {
+          "id": 2,
+          "event": "call",
+          "defined_class": "OpenSSL::PKey::PKey",
+          "method_id": "sign",
+          "path": "OpenSSL::PKey::PKey#sign",
+          "static": false,
+          "parameters": [
+            {
+              "name": "arg",
+              "class": "OpenSSL::Digest::SHA256",
+              "value": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "kind": "req"
+            },
+            {
+              "name": "arg",
+              "class": "String",
+              "value": "the document",
+              "kind": "req"
+            }
+          ],
+          "receiver": {
+            "class": "OpenSSL::PKey::RSA"
+          }
+        },
+        {
+          "id": 3,
+          "event": "return",
+          "parent_id": 2,
+          "return_value": {
+            "class": "String"
+          }
+        },
+        {
+          "id": 4,
+          "event": "return",
+          "parent_id": 1,
+          "return_value": {
+            "class": "String"
+          }
+        },
+        {
+          "id": 5,
+          "event": "call",
+          "defined_class": "IO",
+          "method_id": "write",
+          "path": "IO#write",
+          "static": false,
+          "parameters": [
+            {
+              "name": "arg",
+              "class": "String",
+              "value": "Computed signature",
+              "kind": "rest"
+            }
+          ],
+          "receiver": {
+            "class": "IO"
+          }
+        },
+        {
+          "id": 6,
+          "event": "return",
+          "parent_id": 5,
+          "return_value": {
+            "class": "Integer"
+          }
+        }
+      ]
+      JSON
+      assert_equal '', diff.to_s
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  version: 0.34.0
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-15 00:00:00.000000000 Z
+date: 2020-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -503,6 +503,11 @@ files:
 - test/fixtures/minitest_recorder/appmap.yml
 - test/fixtures/minitest_recorder/lib/hello.rb
 - test/fixtures/minitest_recorder/test/hello_test.rb
+- test/fixtures/openssl_recorder/Gemfile
+- test/fixtures/openssl_recorder/appmap.yml
+- test/fixtures/openssl_recorder/lib/openssl_cert_sign.rb
+- test/fixtures/openssl_recorder/lib/openssl_encrypt.rb
+- test/fixtures/openssl_recorder/lib/openssl_key_sign.rb
 - test/fixtures/process_recorder/appmap.yml
 - test/fixtures/process_recorder/hello.rb
 - test/fixtures/rspec_recorder/Gemfile
@@ -512,6 +517,7 @@ files:
 - test/fixtures/rspec_recorder/spec/labeled_hello_spec.rb
 - test/fixtures/rspec_recorder/spec/plain_hello_spec.rb
 - test/minitest_test.rb
+- test/openssl_test.rb
 - test/record_process_test.rb
 - test/rspec_test.rb
 - test/test_helper.rb