ruby-prof 1.3.1-x64-mingw32 → 1.4.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 806c0eb4c670c555d8db93891b8463b252c01d4ecc53352007d52faab3dc189a
-  data.tar.gz: 104d4c36f8b6c983197dd1f24241033f53357d50d6f8c04082e9ca8de28e3dca
+  metadata.gz: 412103d1d1140848e4e171d010d603e98753a561ee75e62f217013e46848ac64
+  data.tar.gz: 686d22e4138b8fbe4a03f9ba8bfcd1e5523671fb5b4a3f46029676339a2736b8
 SHA512:
-  metadata.gz: 6f7f2a47b1d91fe60796abf2a7c3889232753be3ed44d8639199749cc6d620ea688b99145a52522f25f6ad7d997ed16afd17118fc93893a9c50bd9e614c5b74a
-  data.tar.gz: 554417600fb7e354648f24cabf27ccd122070772bef65900c8e26e62e2fb575f39aa8208ad3bf7ef5e7f0100701ed78c22306e9e61bce770cd9c970d525be979
+  metadata.gz: 374122cf537066f530a7df115941ba2d184229e9d88614ee5901430950d8d87b354fae3faddf9ebdf1fc5b7899b553892f9fa5604a559adc7ad336fb0db36b52
+  data.tar.gz: '058817625f1294f32d1aaba1dcc5f607d9375ec85177f69461be92a9fda972765f211e2d385514360779d6a034f15b4966de082c22d8017a3889c2a856aadd3b'

data/CHANGES

@@ -1,3 +1,15 @@
+1.4.0 (2020-05-12)
+=====================
+* API change - remove merge_fibers support since it resulted in incorrect results or crashes (Charlie Savage)
+* Fix crash when profiling memory usage (Charlie Savage)
+* When tracing execution correctly print out newobj tracepoint events (Charlie Savage)
+* Remove no longer needed code for building extensions (Charlie Savage)
+
+1.3.2 (2020-04-19)
+=====================
+* Fix rack profiler so it is thread safe (Charlie Savage)
+* Fix loading of prebuilt binaries on mingw64 to use Ruby's major and minor version (Charlie Savage)
+
 1.3.1 (2020-03-11)
 =====================
 * Add max_percent and filter_by options to flat printer (Sean McGivern)

data/Rakefile

@@ -38,9 +38,9 @@ Rake::ExtensionTask.new do |ext|
   ext.gem_spec = default_spec
   ext.name = SO_NAME
   ext.ext_dir = "ext/#{SO_NAME}"
-  ext.lib_dir = "lib/#{RUBY_VERSION}"
+  ext.lib_dir = "lib/#{Gem::Version.new(RUBY_VERSION).segments[0..1].join('.')}"
   ext.cross_compile = true
-  ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+  ext.cross_platform = ['x64-mingw32']
 end
 
 # Rake task to build the default package
@@ -58,7 +58,6 @@ if RUBY_PLATFORM.match(/win32|mingw32/)
   win_spec = default_spec.clone
   win_spec.platform = Gem::Platform::CURRENT
   win_spec.files += Dir.glob('lib/**/*.so')
-  win_spec.instance_variable_set(:@cache_file, nil) # Hack to work around gem issue
 
   # Unset extensions
   win_spec.extensions = nil

data/ext/ruby_prof/extconf.rb

@@ -1,35 +1,5 @@
 require "mkmf"
 
-if RUBY_ENGINE != "ruby"
-  STDERR.puts("\n\n***** This gem is MRI-specific. It does not support #{RUBY_ENGINE}. *****\n\n")
-  exit(1)
-end
-
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4.0')
-  STDERR.puts("\n\n***** Ruby version #{RUBY_VERSION} is no longer supported. Please upgrade to 2.3 or higher. *****\n\n")
-  exit(1)
-end
-
-# For the love of bitfields...
-$CFLAGS += ' -std=c99'
-
-# And since we are using C99
-CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
-
-def add_define(name, value = nil)
-  if value
-    $defs.push("-D#{name}=#{value}")
-  else
-    $defs.push("-D#{name}")
-  end
-end
-
-def windows?
-  RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-end
-
-add_define("RUBY_PROF_RUBY_VERSION", RUBY_VERSION.split('.')[0..2].inject(0){|v,d| v*100+d.to_i})
-
 # This function was added in Ruby 2.5, so once Ruby 2.4 is no longer supported this can be removed
 have_func('rb_tracearg_callee_id', ["ruby.h"])
 

data/ext/ruby_prof/rp_call_trees.c

@@ -219,7 +219,7 @@ VALUE prof_call_trees_callers(VALUE self)
         }
     }
 
-    VALUE result = rb_ary_new_capa(callers->num_entries);
+    VALUE result = rb_ary_new_capa((long)callers->num_entries);
     rb_st_foreach(callers, prof_call_trees_collect_aggregates, result);
     rb_st_free_table(callers);
     return result;
@@ -239,7 +239,7 @@ VALUE prof_call_trees_callees(VALUE self)
         rb_st_foreach((*call_tree)->children, prof_call_trees_collect_callees, (st_data_t)callees);
     }
 
-    VALUE result = rb_ary_new_capa(callees->num_entries);
+    VALUE result = rb_ary_new_capa((long)callees->num_entries);
     rb_st_foreach(callees, prof_call_trees_collect_aggregates, result);
     rb_st_free_table(callees);
     return result;

data/ext/ruby_prof/rp_measure_allocations.c

@@ -10,7 +10,7 @@ VALUE total_allocated_objects_key;
 
 static double measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
 {
-    return rb_gc_stat(total_allocated_objects_key);
+    return (double)rb_gc_stat(total_allocated_objects_key);
 }
 
 static double measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)

data/ext/ruby_prof/rp_measure_process_time.c

@@ -24,7 +24,7 @@ static double measure_process_time(rb_trace_arg_t* trace_arg)
     userTimeInt.LowPart = userTime.dwLowDateTime;
     userTimeInt.HighPart = userTime.dwHighDateTime;
 
-    return sysTimeInt.QuadPart + userTimeInt.QuadPart;
+    return (double)(sysTimeInt.QuadPart + userTimeInt.QuadPart);
 #elif !defined(CLOCK_PROCESS_CPUTIME_ID)
     struct rusage usage;
     getrusage(RUSAGE_SELF, &usage);

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -17,7 +17,7 @@ static double measure_wall_time(rb_trace_arg_t* trace_arg)
 #if defined(_WIN32)
     LARGE_INTEGER time;
     QueryPerformanceCounter(&time);
-    return time.QuadPart;
+    return (double)time.QuadPart;
 #elif defined(__APPLE__)
     return mach_absolute_time();// * (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom;
 #elif defined(__linux__)

data/ext/ruby_prof/rp_profile.c

@@ -65,25 +65,19 @@ static const char* get_event_name(rb_event_flag_t event)
         return "fiber-switch";
     case RUBY_EVENT_RAISE:
         return "raise";
+    case RUBY_INTERNAL_EVENT_NEWOBJ:
+        return "newobj";
     default:
         return "unknown";
     }
 }
 
-VALUE get_fiber(prof_profile_t* profile)
-{
-    if (profile->merge_fibers)
-        return rb_thread_current();
-    else
-        return rb_fiber_current();
-}
-
 thread_data_t* check_fiber(prof_profile_t* profile, double measurement)
 {
     thread_data_t* result = NULL;
 
-    /* Get the current thread and fiber information. */
-    VALUE fiber = get_fiber(profile);
+    // Get the current fiber
+    VALUE fiber = rb_fiber_current();
 
     /* We need to switch the profiling context if we either had none before,
      we don't merge fibers and the fiber ids differ, or the thread ids differ. */
@@ -172,7 +166,7 @@ prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_f
 static void prof_trace(prof_profile_t* profile, rb_trace_arg_t* trace_arg, double measurement)
 {
     static VALUE last_fiber = Qnil;
-    VALUE fiber = get_fiber(profile);
+    VALUE fiber = rb_fiber_current();
 
     rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
     const char* event_name = get_event_name(event);
@@ -487,7 +481,6 @@ static VALUE prof_allocate(VALUE klass)
     profile->include_threads_tbl = NULL;
     profile->running = Qfalse;
     profile->allow_exceptions = false;
-    profile->merge_fibers = false;
     profile->exclude_methods_tbl = method_table_create();
     profile->running = Qfalse;
     profile->tracepoints = rb_ary_new();
@@ -529,9 +522,6 @@ prof_stop_threads(prof_profile_t* profile)
                       If not specified, defaults to RubyProf::WALL_TIME.
    allow_exceptions:  Whether to raise exceptions encountered during profiling,
                       or to suppress all exceptions during profiling
-   merge_fibers:      Whether profiling data for a given thread's fibers should all be
-                      subsumed under a single entry. Basically only useful to produce
-                      callgrind profiles.
    track_allocations: Whether to track object allocations while profiling. True or false.
    exclude_common:    Exclude common methods from the profile. True or false.
    exclude_threads:   Threads to exclude from the profiling results.
@@ -546,7 +536,6 @@ static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
     VALUE include_threads = Qnil;
     VALUE exclude_common = Qnil;
     VALUE allow_exceptions = Qfalse;
-    VALUE merge_fibers = Qfalse;
     VALUE track_allocations = Qfalse;
 
     int i;
@@ -566,7 +555,6 @@ static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
             mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
             track_allocations = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("track_allocations")));
             allow_exceptions = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("allow_exceptions")));
-            merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
             exclude_common = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_common")));
             exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
             include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
@@ -587,7 +575,6 @@ static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
     }
     profile->measurer = prof_get_measurer(NUM2INT(mode), track_allocations == Qtrue);
     profile->allow_exceptions = (allow_exceptions == Qtrue);
-    profile->merge_fibers = (merge_fibers == Qtrue);
 
     if (exclude_threads != Qnil)
     {
@@ -679,7 +666,7 @@ static VALUE prof_start(VALUE self)
 
     profile->running = Qtrue;
     profile->paused = Qfalse;
-    profile->last_thread_data = threads_table_insert(profile, get_fiber(profile));
+    profile->last_thread_data = threads_table_insert(profile, rb_fiber_current());
 
     /* open trace file if environment wants it */
     trace_file_name = getenv("RUBY_PROF_TRACE");
@@ -769,11 +756,7 @@ static VALUE prof_stop(VALUE self)
     {
         if (trace_file != stderr && trace_file != stdout)
         {
-#ifdef _MSC_VER
-            _fcloseall();
-#else
             fclose(trace_file);
-#endif
         }
         trace_file = NULL;
     }

data/ext/ruby_prof/rp_profile.h

@@ -26,7 +26,6 @@ typedef struct prof_profile_t
     thread_data_t* last_thread_data;
     double measurement_at_pause_resume;
     bool allow_exceptions;
-    bool merge_fibers;
 } prof_profile_t;
 
 void rp_init_profile(void);

data/ext/ruby_prof/rp_stack.c

@@ -129,7 +129,7 @@ prof_frame_t* prof_frame_push(prof_stack_t* stack, prof_call_tree_t* call_tree,
 prof_frame_t* prof_frame_unshift(prof_stack_t* stack, prof_call_tree_t* parent_call_tree, prof_call_tree_t* call_tree, double measurement)
 {
     if (prof_stack_last(stack))
-        rb_raise(rb_eRuntimeError, "Stach unshift can only be called with an empty stack");
+        rb_raise(rb_eRuntimeError, "Stack unshift can only be called with an empty stack");
 
     parent_call_tree->measurement->total_time = call_tree->measurement->total_time;
     parent_call_tree->measurement->self_time = 0;
@@ -187,7 +187,7 @@ prof_frame_t* prof_frame_pop(prof_stack_t* stack, double measurement)
 
 prof_method_t* prof_find_method(prof_stack_t* stack, VALUE source_file, int source_line)
 {
-    prof_frame_t* frame = stack->ptr;
+    prof_frame_t* frame = prof_stack_last(stack);
     while (frame >= stack->start)
     {
         if (!frame->call_tree)

data/ext/ruby_prof/vc/ruby_prof.sln

@@ -7,16 +7,24 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ruby_prof", "ruby_prof.vcxp
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|ARM64 = Debug|ARM64
 		Debug|x64 = Debug|x64
 		Debug|x86 = Debug|x86
+		Release|ARM = Release|ARM
+		Release|ARM64 = Release|ARM64
 		Release|x64 = Release|x64
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Debug|ARM.ActiveCfg = Debug|Win32
+		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Debug|ARM64.ActiveCfg = Debug|Win32
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Debug|x64.ActiveCfg = Debug|x64
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Debug|x64.Build.0 = Debug|x64
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Debug|x86.ActiveCfg = Debug|Win32
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Debug|x86.Build.0 = Debug|Win32
+		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Release|ARM.ActiveCfg = Release|Win32
+		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Release|ARM64.ActiveCfg = Release|Win32
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Release|x64.ActiveCfg = Release|x64
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Release|x64.Build.0 = Release|x64
 		{6B4978F4-3B5F-4D38-81A8-069EC28CC069}.Release|x86.ActiveCfg = Release|Win32

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -64,7 +64,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt>.so</TargetExt>
-    <OutDir>..\..\..\lib</OutDir>
+    <OutDir>..\..\..\lib\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -102,17 +102,28 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.7.0vc\include\ruby-2.7.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.7.0vc\include\ruby-2.7.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.7.1vc\include\ruby-2.7.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.7.1vc\include\ruby-2.7.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>HAVE_RB_TRACEARG_CALLEE_ID;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level3</WarningLevel>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.7.0vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.7.1vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>x64-vcruntime140-ruby270.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
       <SubSystem>Console</SubSystem>
     </Link>
   </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-2.7.1vc\include\ruby-2.7.0\x64-mswin64_140;C:\msys64\usr\local\ruby-2.7.1vc\include\ruby-2.7.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-2.7.1vc\lib</AdditionalLibraryDirectories>
+      <AdditionalDependencies>x64-vcruntime140-ruby270.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="..\rp_aggregate_call_tree.h" />
     <ClInclude Include="..\rp_allocation.h" />

data/ext/ruby_prof/vc/ruby_prof_linux.vcxproj

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x86">
+      <Configuration>Debug</Configuration>
+      <Platform>x86</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x86">
+      <Configuration>Release</Configuration>
+      <Platform>x86</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{fd79d690-c808-464c-a46b-01188609976e}</ProjectGuid>
+    <Keyword>Linux</Keyword>
+    <RootNamespace>Project1</RootNamespace>
+    <MinimumVisualStudioVersion>15.0</MinimumVisualStudioVersion>
+    <ApplicationType>Linux</ApplicationType>
+    <ApplicationTypeRevision>1.0</ApplicationTypeRevision>
+    <TargetLinuxPlatform>Generic</TargetLinuxPlatform>
+    <LinuxProjectType>{2238F9CD-F817-4ECC-BD14-2524D2669B35}</LinuxProjectType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x86'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>WSL_1_0</PlatformToolset>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>WSL_1_0</PlatformToolset>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings" />
+  <ImportGroup Label="Shared" />
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <TargetName>ruby_prof</TargetName>
+    <OutDir>../usr/local/lib64/gems/ruby/ruby-prof-1.3.2/</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <TargetName>ruby_prof</TargetName>
+  </PropertyGroup>
+  <ItemGroup>
+    <ClInclude Include="..\rp_aggregate_call_tree.h" />
+    <ClInclude Include="..\rp_allocation.h" />
+    <ClInclude Include="..\rp_call_tree.h" />
+    <ClInclude Include="..\rp_call_trees.h" />
+    <ClInclude Include="..\rp_measurement.h" />
+    <ClInclude Include="..\rp_method.h" />
+    <ClInclude Include="..\rp_profile.h" />
+    <ClInclude Include="..\rp_stack.h" />
+    <ClInclude Include="..\rp_thread.h" />
+    <ClInclude Include="..\ruby_prof.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\rp_aggregate_call_tree.c" />
+    <ClCompile Include="..\rp_allocation.c" />
+    <ClCompile Include="..\rp_call_tree.c" />
+    <ClCompile Include="..\rp_call_trees.c" />
+    <ClCompile Include="..\rp_measurement.c" />
+    <ClCompile Include="..\rp_measure_allocations.c" />
+    <ClCompile Include="..\rp_measure_memory.c" />
+    <ClCompile Include="..\rp_measure_process_time.c" />
+    <ClCompile Include="..\rp_measure_wall_time.c" />
+    <ClCompile Include="..\rp_method.c" />
+    <ClCompile Include="..\rp_profile.c" />
+    <ClCompile Include="..\rp_stack.c" />
+    <ClCompile Include="..\rp_thread.c" />
+    <ClCompile Include="..\ruby_prof.c" />
+  </ItemGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <LibraryDependencies>ruby</LibraryDependencies>
+    </Link>
+    <ClCompile>
+      <PreprocessorDefinitions>
+      </PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Link>
+      <LibraryDependencies>ruby</LibraryDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets" />
+</Project>

data/lib/ruby-prof.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
+require 'rubygems/version'
 
 # Load the C-based binding.
 begin
-  RUBY_VERSION =~ /(\d+\.\d+\.\d+)/
-  require "#{$1}/ruby_prof.so"
+  version = Gem::Version.new(RUBY_VERSION)
+  require "#{version.segments[0..1].join('.')}/ruby_prof.so"
 rescue LoadError
   require "ruby_prof.so"
 end

data/lib/ruby-prof/rack.rb

@@ -5,43 +5,37 @@ module Rack
   class RubyProf
     def initialize(app, options = {})
       @app = app
+      @options = options
+      @options[:min_percent] ||= 1
 
-      options[:min_percent] ||= 1
+      @tmpdir = options[:path] || Dir.tmpdir
+      FileUtils.mkdir_p(@tmpdir)
 
-      options[:path] ||= Dir.tmpdir
-      FileUtils.mkdir_p(options[:path])
+      @printer_klasses = @options[:printers]  || {::RubyProf::FlatPrinter => 'flat.txt',
+                                                  ::RubyProf::GraphPrinter => 'graph.txt',
+                                                  ::RubyProf::GraphHtmlPrinter => 'graph.html',
+                                                  ::RubyProf::CallStackPrinter => 'call_stack.html'}
 
       @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
       @only_paths = options[:only_paths]
-
-      @max_requests = options[:max_requests]
-
-      @options = options
     end
 
     def call(env)
       request = Rack::Request.new(env)
 
       if should_profile?(request.path)
-        profiler.resume
         begin
-          result = @app.call(env)
-        ensure
-          profiler.pause
-        end
+          result = nil
+          data = ::RubyProf::Profile.profile(profiling_options) do
+            result = @app.call(env)
+          end
 
-        if profiler.max_requests_reached?
-          prefix = if aggregate_requests?
-              nil
-            else
-              request.path.gsub('/', '-')[1..-1]
-            end
+          path = request.path.gsub('/', '-')
+          path.slice!(0)
 
-          profiler.print!(prefix)
-          delete_profiler!
+          print(data, path)
+          result
         end
-
-        result
       else
         @app.call(env)
       end
@@ -49,126 +43,53 @@ module Rack
 
     private
 
-    class RackProfiler
-      def initialize(options)
-        @options = options
-
-        @profile = ::RubyProf::Profile.new(profiling_options)
-        @profile.start
-        @profile.pause
-
-        @printer_klasses = options[:printers] || default_printers
-
-        @tmpdir = options[:path]
-
-        @max_requests = options[:max_requests] || 1
-        @requests_count = 0
+    def should_profile?(path)
+      return false if paths_match?(path, @skip_paths)
 
-        @printed = false
-        # if running across multiple requests, we want to make sure that the
-        # ongoing profile is not lost if the process shuts down before the
-        # max request count is reached
-        ObjectSpace.define_finalizer(self, proc { print! })
-      end
+      @only_paths ? paths_match?(path, @only_paths) : true
+    end
 
-      def resume
-        @profile.resume
-      end
+    def paths_match?(path, paths)
+      paths.any? { |skip_path| skip_path =~ path }
+    end
 
-      def pause
-        @profile.pause
-        @requests_count += 1
+    def profiling_options
+      options = {}
+      options[:measure_mode] = ::RubyProf.measure_mode
+      options[:exclude_threads] =
+        if @options[:ignore_existing_threads]
+          Thread.list.select{|t| t != Thread.current}
+        else
+          ::RubyProf.exclude_threads
+        end
+      if @options[:request_thread_only]
+        options[:include_threads] = [Thread.current]
       end
-
-      def max_requests_reached?
-        @requests_count >= @max_requests
+      if @options[:merge_fibers]
+        options[:merge_fibers] = true
       end
+      options
+    end
 
-      def print!(prefix = nil)
-        return false if @printed || @requests_count == 0
-
-        data = @profile.stop
-
-        prefix ||= "multi-requests-#{@requests_count}"
-
-        @printer_klasses.each do |printer_klass, base_name|
-          printer = printer_klass.new(data)
-
-          if base_name.respond_to?(:call)
-            base_name = base_name.call
-          end
+    def print(data, path)
+      @printer_klasses.each do |printer_klass, base_name|
+        printer = printer_klass.new(data)
 
-          if printer_klass == ::RubyProf::MultiPrinter \
-              || printer_klass == ::RubyProf::CallTreePrinter
-            printer.print(@options.merge(:profile => "#{prefix}-#{base_name}"))
-          else
-            file_name = ::File.join(@tmpdir, "#{prefix}-#{base_name}")
-            ::File.open(file_name, 'wb') do |file|
-              printer.print(file, @options)
-            end
-          end
+        if base_name.respond_to?(:call)
+          base_name = base_name.call
         end
 
-        @printed = true
-      end
-
-      private
-
-      def profiling_options
-        options = {}
-        options[:measure_mode] = ::RubyProf.measure_mode
-        options[:exclude_threads] =
-          if @options[:ignore_existing_threads]
-            Thread.list.select{|t| t != Thread.current}
-          else
-            ::RubyProf.exclude_threads
+        if printer_klass == ::RubyProf::MultiPrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        elsif printer_klass == ::RubyProf::CallTreePrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        else
+          file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
+          ::File.open(file_name, 'wb') do |file|
+            printer.print(file, @options)
           end
-        if @options[:request_thread_only]
-          options[:include_threads] = [Thread.current]
         end
-        if @options[:merge_fibers]
-          options[:merge_fibers] = true
-        end
-        options
-      end
-
-      def default_printers
-        {::RubyProf::FlatPrinter => 'flat.txt',
-         ::RubyProf::GraphPrinter => 'graph.txt',
-         ::RubyProf::GraphHtmlPrinter => 'graph.html',
-         ::RubyProf::CallStackPrinter => 'call_stack.html'}
       end
     end
-
-    def profiler
-      if aggregate_requests?
-        @@_shared_profiler ||= RackProfiler.new(@options)
-      else
-        @_profiler ||= RackProfiler.new(@options)
-      end
-    end
-
-    def delete_profiler!
-      if aggregate_requests?
-        @@_shared_profiler.print! if @@_shared_profiler
-        @@_shared_profiler = nil
-      else
-        @_profiler = nil
-      end
-    end
-
-    def aggregate_requests?
-      !@max_requests.nil?
-    end
-
-    def should_profile?(path)
-      return false if paths_match?(path, @skip_paths)
-
-      @only_paths ? paths_match?(path, @only_paths) : true
-    end
-
-    def paths_match?(path, paths)
-      paths.any? { |skip_path| skip_path =~ path }
-    end
   end
 end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.3.1"
+  VERSION = "1.4.0"
 end

data/test/client.rb

@@ -0,0 +1,9 @@
+# tcp_client.rb
+require 'socket'
+client = TCPSocket.new('localhost', 9090)
+
+client.puts("HI")
+line = client.gets
+puts line
+
+client.close

data/test/fiber_test.rb

@@ -8,254 +8,122 @@ require 'set'
 
 # --  Tests ----
 class FiberTest < TestCase
+
   def enumerator_with_fibers
-    @fiber_ids << Fiber.current.object_id
     enum = Enumerator.new do |yielder|
       [1,2].each do |x|
-        @fiber_ids << Fiber.current.object_id
-        sleep 0.1
         yielder.yield x
       end
     end
-    while true
-      begin
-        enum.next
-      rescue StopIteration
-        break
-      end
-    end
-    sleep 0.1
+
+    enum.next
+    enum.next
+  end
+
+  def fiber_yield_resume
+    fiber = Fiber.new do
+              Fiber.yield 1
+              Fiber.yield 2
+            end
+
+    fiber.resume
+    fiber.resume
   end
 
   def setup
     # Need to use wall time for this test due to the sleep calls
     RubyProf::measure_mode = RubyProf::WALL_TIME
-    @fiber_ids  = Set.new
-    @root_fiber = Fiber.current.object_id
-    @thread_id  = Thread.current.object_id
   end
 
   def test_fibers
     result  = RubyProf.profile { enumerator_with_fibers }
 
-    profiled_fiber_ids = result.threads.map(&:fiber_id)
-    assert_equal(2, result.threads.length)
-    assert_equal([@thread_id], result.threads.map(&:id).uniq)
-    assert_equal(@fiber_ids, Set.new(profiled_fiber_ids))
+    assert_equal(2, result.threads.size)
 
-    assert profiled_fiber_ids.include?(@root_fiber)
-    assert(root_fiber_profile = result.threads.detect{|t| t.fiber_id == @root_fiber})
-    assert(enum_fiber_profile = result.threads.detect{|t| t.fiber_id != @root_fiber})
-    assert_in_delta(0.33, root_fiber_profile.total_time, 0.05)
-    assert_in_delta(0.33, enum_fiber_profile.total_time, 0.05)
-
-    methods = result.threads[0].methods.sort.reverse
-    assert_equal(12, methods.count)
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
 
     method = methods[0]
     assert_equal('FiberTest#test_fibers', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.33, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.33, method.children_time, 0.05)
 
     method = methods[1]
     assert_equal('FiberTest#enumerator_with_fibers', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.33, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.33, method.children_time, 0.05)
 
     method = methods[2]
     assert_equal('Enumerator#next', method.full_name)
-    assert_equal(3, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0.22, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    assert_equal(2, method.called)
 
     method = methods[3]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0.11, method.total_time, 0.05)
-    assert_in_delta(0.11, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    # Since these methods have such short times their order is a bit indeterminate
-    method = methods.detect {|a_method| a_method.full_name == 'Class#new'}
     assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-      method = methods.detect {|a_method| a_method.full_name == 'Set#<<'}
-      assert_equal('Set#<<', method.full_name)
-      assert_equal(1, method.called)
-      assert_in_delta(0, method.total_time, 0.05)
-      assert_in_delta(0, method.self_time, 0.05)
-      assert_in_delta(0, method.wait_time, 0.05)
-      assert_in_delta(0, method.children_time, 0.05)
-    end
 
-    method = methods.detect {|a_method| a_method.full_name == 'Module#==='}
-    assert_equal('Module#===', method.full_name)
+    method = methods[4]
+    assert_equal('Enumerator#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Kernel#object_id'}
-    assert_equal('Kernel#object_id', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    thread2 = result.threads[1]
+    methods = thread2.methods.sort.reverse
+    assert_equal(4, methods.count)
 
-    method = methods.detect {|a_method| a_method.full_name == '<Class::Fiber>#current'}
-    assert_equal('<Class::Fiber>#current', method.full_name)
+    method = methods[0]
+    assert_equal('Enumerator#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Exception#exception'}
-    assert_equal('Exception#exception', method.full_name)
+    method = methods[1]
+    assert_equal('Enumerator::Generator#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Exception#backtrace'}
-    assert_equal('Exception#backtrace', method.full_name)
+    method = methods[2]
+    assert_equal('Array#each', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Enumerator#initialize'}
-    assert_equal('Enumerator#initialize', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    method = methods[3]
+    assert_equal('Enumerator::Yielder#yield', method.full_name)
+    assert_equal(2, method.called)
+  end
 
-    methods = result.threads[1].methods.sort.reverse
+  def test_fiber_resume
+    result  = RubyProf.profile { fiber_yield_resume }
 
-    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6.0')
-      assert_equal(10, methods.count)
-    else
-      assert_equal(11, methods.count)
-    end
+    assert_equal(2, result.threads.size)
+
+    thread1 = result.threads[0]
+    methods = thread1.methods.sort.reverse
+    assert_equal(5, methods.count)
 
     method = methods[0]
-    assert_equal('RubyProf::Profile#_inserted_parent_', method.full_name)
+    assert_equal('FiberTest#test_fiber_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.33, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0.11, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
 
     method = methods[1]
-    assert_equal('Enumerator#each', method.full_name)
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
 
     method = methods[2]
-    assert_equal('Enumerator::Generator#each', method.full_name)
-    assert_equal(1, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
+    assert_equal('Fiber#resume', method.full_name)
+    assert_equal(2, method.called)
 
     method = methods[3]
-    assert_equal('Array#each', method.full_name)
+    assert_equal('Class#new', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0.22, method.children_time, 0.05)
 
     method = methods[4]
-    assert_equal('Kernel#sleep', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0.22, method.total_time, 0.05)
-    assert_in_delta(0.22, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    # Since these methods have such short times their order is a bit indeterminate
-    method = methods.detect {|a_method| a_method.full_name == 'Exception#initialize'}
-    assert_equal('Exception#initialize', method.full_name)
+    assert_equal('Fiber#initialize', method.full_name)
     assert_equal(1, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-
-    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
-      method = methods.detect {|a_method| a_method.full_name == 'Set#<<'}
-      assert_equal('Set#<<', method.full_name)
-      assert_equal(2, method.called)
-      assert_in_delta(0, method.total_time, 0.05)
-      assert_in_delta(0, method.self_time, 0.05)
-      assert_in_delta(0, method.wait_time, 0.05)
-      assert_in_delta(0, method.children_time, 0.05)
-    end
 
-    method = methods.detect {|a_method| a_method.full_name == 'Kernel#object_id'}
-    assert_equal('Kernel#object_id', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    thread1 = result.threads[1]
+    methods = thread1.methods.sort.reverse
+    assert_equal(2, methods.count)
 
-    method = methods.detect {|a_method| a_method.full_name == 'Enumerator::Yielder#yield'}
-    assert_equal('Enumerator::Yielder#yield', method.full_name)
-    assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
+    method = methods[0]
+    assert_equal('FiberTest#fiber_yield_resume', method.full_name)
+    assert_equal(1, method.called)
 
-    method = methods.detect {|a_method| a_method.full_name == '<Class::Fiber>#current'}
-    assert_equal('<Class::Fiber>#current', method.full_name)
+    method = methods[1]
+    assert_equal('<Class::Fiber>#yield', method.full_name)
     assert_equal(2, method.called)
-    assert_in_delta(0, method.total_time, 0.05)
-    assert_in_delta(0, method.self_time, 0.05)
-    assert_in_delta(0, method.wait_time, 0.05)
-    assert_in_delta(0, method.children_time, 0.05)
-  end
-
-  def test_merged_fibers
-    result  = RubyProf.profile(merge_fibers: true) { enumerator_with_fibers }
-
-    assert_equal(1, result.threads.length)
-
-    thread = result.threads.first
-    assert_equal(thread.id, thread.fiber_id)
-    assert_in_delta(0.3, thread.total_time, 0.05)
-
-    assert(method_next = thread.methods.detect{|m| m.full_name == "Enumerator#next"})
-    assert(method_each = thread.methods.detect{|m| m.full_name == "Enumerator#each"})
-
-    assert_in_delta(0.2, method_next.total_time, 0.05)
-    assert_in_delta(0.2, method_each.total_time, 0.05)
   end
 end

data/test/rack_test.rb

@@ -24,16 +24,6 @@ module Rack
   end
 end
 
-module Rack
-  class RubyProf
-    attr_reader :_profiler
-
-    def public_delete_profiler!
-      delete_profiler!
-    end
-  end
-end
-
 class RackTest < TestCase
   def test_create_print_path
     path = Dir.mktmpdir
@@ -100,58 +90,4 @@ class RackTest < TestCase
     file_path = ::File.join(path, 'path-to-resource.json-dynamic.txt')
     assert(File.exist?(file_path))
   end
-
-  def test_works_for_multiple_requests
-    path = Dir.mktmpdir
-
-    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 2)
-
-    # make a 1st request, and check that this didn't create any files
-    adapter.call(:fake_env)
-    assert(Dir["#{path}/*"].empty?)
-
-    # now a second request should create all the expected files
-    adapter.call(:fake_env)
-    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
-      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
-      assert(File.exist?(file_path))
-    end
-
-    # let's clean up
-    FileUtils.rm_rf(Dir["#{path}/*"])
-
-    # and do the same again for the next 2 requests
-    adapter.call(:fake_env)
-    assert(Dir["#{path}/*"].empty?)
-
-    adapter.call(:fake_env)
-    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
-      file_path = ::File.join(path, "multi-requests-2-#{base_name}")
-      assert(File.exist?(file_path))
-    end
-  end
-
-  def test_tries_to_print_results_if_shut_down_before_max_requests_reached
-    path = Dir.mktmpdir
-
-    adapter = Rack::RubyProf.new(FakeRackApp.new, :path => path, :max_requests => 100)
-
-    # make a 1st request, and check that this didn't create any files
-    adapter.call(:fake_env)
-    assert(Dir["#{path}/*"].empty?)
-
-    adapter.public_delete_profiler!
-
-    %w(flat.txt graph.txt graph.html call_stack.html).each do |base_name|
-      file_path = ::File.join(path, "multi-requests-1-#{base_name}")
-      assert(File.exist?(file_path))
-    end
-  end
-
-  def test_it_uses_separate_profilers_if_not_aggregating_multiple_requests
-    adapter1 = Rack::RubyProf.new(FakeRackApp.new)
-    adapter2 = Rack::RubyProf.new(FakeRackApp.new)
-
-    assert(adapter1.object_id != adapter2.object_id)
-  end
 end

data/test/server.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'fiber'
+
+# The full implementation is given here, in order to show all the parts. A simpler implementation is given below.
+class Reactor
+  def initialize
+    @readable = {}
+    @writable = {}
+  end
+
+  def run
+    while @readable.any? or @writable.any?
+      readable, writable = IO.select(@readable.keys, @writable.keys, [])
+
+      readable.each do |io|
+        @readable[io].resume
+      end
+
+      writable.each do |io|
+        @writable[io].resume
+      end
+    end
+  end
+
+  def wait_readable(io)
+    @readable[io] = Fiber.current
+    Fiber.yield
+    @readable.delete(io)
+
+    return yield if block_given?
+  end
+
+  def wait_writable(io)
+    @writable[io] = Fiber.current
+    Fiber.yield
+    @writable.delete(io)
+
+    return yield if block_given?
+  end
+end
+
+server = TCPServer.new('localhost', 9090)
+reactor = Reactor.new
+
+Fiber.new do
+  loop do
+    client = reactor.wait_readable(server) do
+      server.accept
+    end
+
+    Fiber.new do
+      while buffer = reactor.wait_readable(client) {client.gets}
+        reactor.wait_writable(client)
+        client.puts(buffer)
+      end
+
+      client.close
+    end.resume
+  end
+end.resume
+
+reactor.run

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prof
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: x64-mingw32
 authors:
 - Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-12 00:00:00.000000000 Z
+date: 2020-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -99,8 +99,7 @@ files:
 - ext/ruby_prof/ruby_prof.h
 - ext/ruby_prof/vc/ruby_prof.sln
 - ext/ruby_prof/vc/ruby_prof.vcxproj
-- lib/2.6.5/ruby_prof.so
-- lib/2.7.0/ruby_prof.so
+- ext/ruby_prof/vc/ruby_prof_linux.vcxproj
 - lib/ruby-prof.rb
 - lib/ruby-prof/assets/call_stack_printer.html.erb
 - lib/ruby-prof/assets/call_stack_printer.png
@@ -132,6 +131,7 @@ files:
 - test/basic_test.rb
 - test/call_tree_visitor_test.rb
 - test/call_trees_test.rb
+- test/client.rb
 - test/duplicate_names_test.rb
 - test/dynamic_method_test.rb
 - test/enumerable_test.rb
@@ -164,6 +164,7 @@ files:
 - test/printing_recursive_graph_test.rb
 - test/rack_test.rb
 - test/recursive_test.rb
+- test/server.rb
 - test/singleton_test.rb
 - test/stack_printer_test.rb
 - test/start_stop_test.rb
@@ -178,7 +179,7 @@ metadata:
   bug_tracker_uri: https://github.com/ruby-prof/ruby-prof/issues
   changelog_uri: https://github.com/ruby-prof/ruby-prof/blob/master/CHANGES
   documentation_uri: https://ruby-prof.github.io/
-  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.3.1
+  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.4.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -194,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Fast Ruby profiler