memory-profiler 1.1.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf7841a9d0249712c9bd140447e0063b5b543cae942bc1dedc09682472f3aaf
-  data.tar.gz: 14f9521f93447843b93aff1dfe15b12fce5f9491bb6a6055caf1d90cce304f17
+  metadata.gz: 45474399b764a755546268feed4710ae9c647a8265cd933be82e35b1f390e820
+  data.tar.gz: 47d263fc3fa31b8013d7eded37f22e74b8912b3029d6b5d9051f3a35e1b4aa6a
 SHA512:
-  metadata.gz: 43ba6c482b4f9e6e80e5f3213435b158b954087790e19ac4effb77fe4d06d602027c6668f63aa0b68bd592c073ac112f98735da4249d68829913d1328bb21cb4
-  data.tar.gz: b30e212a1d6a315a4fc94d9dfad066d0f1e2ec4f73dbf7f5bf757bd85e6279ddb088e87168cb6cc158b99fcb218df5ec6f3e7ca60254c8a071478959cbda4817
+  metadata.gz: d4afc54d3841e0517e966ca0e5015320cacdc747a0ed1b2004b3b5ed043345139e3d7125ee79a4ff8bc3781f04d88399f2373553fe870143adf92b7b745fe97c
+  data.tar.gz: e99bbeda7a53e23c30e90981711f88651fd7efd453d86ba9748b11485dd2fcad6562038b91390a1f692694508e71c0aa4221ec25f2ebe61663835f667973292e

data/ext/memory/profiler/allocations.c

@@ -12,8 +12,9 @@ static VALUE Memory_Profiler_Allocations = Qnil;
 
 // Helper to mark object_states table values
 static int Memory_Profiler_Allocations_object_states_mark(st_data_t key, st_data_t value, st_data_t arg) {
-	VALUE object = (VALUE)key;
-	rb_gc_mark_movable(object);
+	// Don't mark the object, we use it as a key but we never use it as an object, and we don't want to retain it.
+	// VALUE object = (VALUE)key;
+	// rb_gc_mark_movable(object);
 
 	VALUE state = (VALUE)value;
 	if (!NIL_P(state)) {

data/ext/memory/profiler/capture.c

@@ -13,6 +13,8 @@
 
 enum {
 	DEBUG = 0,
+	DEBUG_EVENT_QUEUES = 0,
+	DEBUG_STATE = 0,
 };
 
 static VALUE Memory_Profiler_Capture = Qnil;
@@ -21,8 +23,20 @@ static VALUE Memory_Profiler_Capture = Qnil;
 static VALUE sym_newobj;
 static VALUE sym_freeobj;
 
-// Queue item - freed object data to be processed after GC
-struct Memory_Profiler_Queue_Item {
+// Queue item - new object data to be processed via postponed job
+struct Memory_Profiler_Newobj_Queue_Item {
+	// The class of the new object:
+	VALUE klass;
+
+	// The Allocations wrapper:
+	VALUE allocations;
+
+	// The newly allocated object:
+	VALUE object;
+};
+
+// Queue item - freed object data to be processed via postponed job
+struct Memory_Profiler_Freeobj_Queue_Item {
 	// The class of the freed object:
 	VALUE klass;
 
@@ -41,10 +55,13 @@ struct Memory_Profiler_Capture {
 	// Is tracking enabled (via start/stop):
 	int enabled;
 	
-	// Queue for freed objects (processed after GC via postponed job)
-	struct Memory_Profiler_Queue freed_queue;
+	// Queue for new objects (processed via postponed job):
+	struct Memory_Profiler_Queue newobj_queue;
+	
+	// Queue for freed objects (processed via postponed job):
+	struct Memory_Profiler_Queue freeobj_queue;
 	
-	// Handle for the postponed job
+	// Handle for the postponed job (processes both queues)
 	rb_postponed_job_handle_t postponed_job_handle;
 };
 
@@ -73,9 +90,17 @@ static void Memory_Profiler_Capture_mark(void *ptr) {
 		st_foreach(capture->tracked_classes, Memory_Profiler_Capture_tracked_classes_mark, 0);
 	}
 	
+	// Mark new objects in the queue:
+	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
+		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
+		rb_gc_mark_movable(newobj->klass);
+		rb_gc_mark_movable(newobj->allocations);
+		rb_gc_mark_movable(newobj->object);
+	}
+	
 	// Mark freed objects in the queue:
-	for (size_t i = 0; i < capture->freed_queue.count; i++) {
-		struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freed_queue, i);
+	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
+		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
 		rb_gc_mark_movable(freed->klass);
 		rb_gc_mark_movable(freed->allocations);
 
@@ -93,8 +118,9 @@ static void Memory_Profiler_Capture_free(void *ptr) {
 		st_free_table(capture->tracked_classes);
 	}
 	
-	// Free the queue (elements are stored directly, just free the queue)
-	Memory_Profiler_Queue_free(&capture->freed_queue);
+	// Free both queues (elements are stored directly, just free the queues)
+	Memory_Profiler_Queue_free(&capture->newobj_queue);
+	Memory_Profiler_Queue_free(&capture->freeobj_queue);
 	
 	xfree(capture);
 }
@@ -108,8 +134,9 @@ static size_t Memory_Profiler_Capture_memsize(const void *ptr) {
 		size += capture->tracked_classes->num_entries * (sizeof(st_data_t) + sizeof(struct Memory_Profiler_Capture_Allocations));
 	}
 	
-	// Add size of freed queue (elements stored directly)
-	size += capture->freed_queue.capacity * capture->freed_queue.element_size;
+	// Add size of both queues (elements stored directly)
+	size += capture->newobj_queue.capacity * capture->newobj_queue.element_size;
+	size += capture->freeobj_queue.capacity * capture->freeobj_queue.element_size;
 	
 	return size;
 }
@@ -150,9 +177,19 @@ static void Memory_Profiler_Capture_compact(void *ptr) {
 		}
 	}
 	
+	// Update new objects in the queue
+	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
+		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
+		
+		// Update all VALUEs if they moved during compaction
+		newobj->klass = rb_gc_location(newobj->klass);
+		newobj->allocations = rb_gc_location(newobj->allocations);
+		newobj->object = rb_gc_location(newobj->object);
+	}
+	
 	// Update freed objects in the queue
-	for (size_t i = 0; i < capture->freed_queue.count; i++) {
-		struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freed_queue, i);
+	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
+		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
 		
 		// Update all VALUEs if they moved during compaction
 		freed->klass = rb_gc_location(freed->klass);
@@ -190,20 +227,52 @@ const char *event_flag_name(rb_event_flag_t event_flag) {
 	}
 }
 
-// Postponed job callback - processes queued freed objects
-// This runs after GC completes, when it's safe to call Ruby code
-static void Memory_Profiler_Capture_process_freed_queue(void *arg) {
+// Postponed job callback - processes queued new and freed objects
+// This runs when it's safe to call Ruby code (not during allocation or GC)
+// IMPORTANT: Process newobj queue first, then freeobj queue to maintain order
+static void Memory_Profiler_Capture_process_queues(void *arg) {
 	VALUE self = (VALUE)arg;
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
 	
-	if (DEBUG) {
-		fprintf(stderr, "Processing freed queue with %zu entries\n", capture->freed_queue.count);
+	if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Processing queues: %zu newobj, %zu freeobj\n", 
+		capture->newobj_queue.count, capture->freeobj_queue.count);
+	
+	// Disable tracking during queue processing to prevent infinite loop
+	// (rb_funcall can allocate, which would trigger more NEWOBJ events)
+	int was_enabled = capture->enabled;
+	capture->enabled = 0;
+	
+	// First, process all new objects in the queue
+	for (size_t i = 0; i < capture->newobj_queue.count; i++) {
+		struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_at(&capture->newobj_queue, i);
+		VALUE klass = newobj->klass;
+		VALUE allocations = newobj->allocations;
+		VALUE object = newobj->object;
+		
+		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
+		
+		// Call the Ruby callback with (klass, :newobj, nil) - callback returns state to store
+		if (!NIL_P(record->callback)) {
+			VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
+			
+			// Store the state if callback returned something
+			if (!NIL_P(state)) {
+				if (!record->object_states) {
+					record->object_states = st_init_numtable();
+				}
+				
+				if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_process_queues: Storing state for object: %p (%s)\n", 
+					(void *)object, rb_class2name(klass));
+
+				st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
+			}
+		}
 	}
 	
-	// Process all freed objects in the queue
-	for (size_t i = 0; i < capture->freed_queue.count; i++) {
-		struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freed_queue, i);
+	// Then, process all freed objects in the queue
+	for (size_t i = 0; i < capture->freeobj_queue.count; i++) {
+		struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_at(&capture->freeobj_queue, i);
 		VALUE klass = freed->klass;
 		VALUE allocations = freed->allocations;
 		VALUE state = freed->state;
@@ -216,38 +285,43 @@ static void Memory_Profiler_Capture_process_freed_queue(void *arg) {
 		}
 	}
 	
-	// Clear the queue (elements are reused on next cycle)
-	Memory_Profiler_Queue_clear(&capture->freed_queue);
+	// Clear both queues (elements are reused on next cycle)
+	Memory_Profiler_Queue_clear(&capture->newobj_queue);
+	Memory_Profiler_Queue_clear(&capture->freeobj_queue);
+	
+	// Restore tracking state
+	capture->enabled = was_enabled;
 }
 
 // Handler for NEWOBJ event
+// SAFE: No longer calls Ruby code directly - queues for deferred processing
 static void Memory_Profiler_Capture_newobj_handler(VALUE self, struct Memory_Profiler_Capture *capture, VALUE klass, VALUE object) {
 	st_data_t allocations_data;
 	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
 		VALUE allocations = (VALUE)allocations_data;
 		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
 		record->new_count++;
+		
+		// If we have a callback, queue the newobj for later processing
 		if (!NIL_P(record->callback)) {
-			// Invoke callback - runs during NEWOBJ with GC disabled
-			// CRITICAL CALLBACK REQUIREMENTS:
-			// - Must be FAST (runs on EVERY allocation)
-			// - Must NOT call GC.start (will deadlock)
-			// - Must NOT block/sleep (stalls all allocations system-wide)
-			// - Should NOT raise exceptions (will propagate to allocating code)
-			// - Avoid allocating objects (causes re-entry)
-			
-			// Call with (klass, :newobj, nil) - callback returns state to store
-			VALUE state = rb_funcall(record->callback, rb_intern("call"), 3, klass, sym_newobj, Qnil);
-			
-			// Store the state if callback returned something
-			if (!NIL_P(state)) {
-				if (!record->object_states) {
-					record->object_states = st_init_numtable();
-				}
-				st_insert(record->object_states, (st_data_t)object, (st_data_t)state);
-				// Notify GC about the state VALUE stored in the table
-				RB_OBJ_WRITTEN(self, Qnil, state);
+			// Push a new item onto the queue (returns pointer to write to)
+			// NOTE: realloc is safe during allocation (doesn't trigger Ruby allocation)
+			struct Memory_Profiler_Newobj_Queue_Item *newobj = Memory_Profiler_Queue_push(&capture->newobj_queue);
+			if (newobj) {
+				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Queued newobj, queue size now: %zu/%zu\n", 
+					capture->newobj_queue.count, capture->newobj_queue.capacity);
+				// Write directly to the allocated space
+				newobj->klass = klass;
+				newobj->allocations = allocations;
+				newobj->object = object;
+				
+				// Trigger postponed job to process the queue
+				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Triggering postponed job to process queues\n");
+				rb_postponed_job_trigger(capture->postponed_job_handle);
+			} else {
+				if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Failed to queue newobj, out of memory\n");
 			}
+			// If push failed (out of memory), silently drop this newobj event
 		}
 	} else {
 		// Create record for this class (first time seeing it)
@@ -280,22 +354,30 @@ static void Memory_Profiler_Capture_freeobj_handler(VALUE self, struct Memory_Pr
 		
 		// If we have a callback and detailed tracking, queue the freeobj for later processing
 		if (!NIL_P(record->callback) && record->object_states) {
+			if (DEBUG_STATE) fprintf(stderr, "Memory_Profiler_Capture_freeobj_handler: Looking up state for object: %p\n", (void *)object);
+
 			// Look up state stored during NEWOBJ
 			st_data_t state_data;
 			if (st_delete(record->object_states, (st_data_t *)&object, &state_data)) {
+				if (DEBUG_STATE) fprintf(stderr, "Found state for object: %p\n", (void *)object);
 				VALUE state = (VALUE)state_data;
 				
 				// Push a new item onto the queue (returns pointer to write to)
 				// NOTE: realloc is safe during GC (doesn't trigger Ruby allocation)
-				struct Memory_Profiler_Queue_Item *freed = Memory_Profiler_Queue_push(&capture->freed_queue);
+				struct Memory_Profiler_Freeobj_Queue_Item *freed = Memory_Profiler_Queue_push(&capture->freeobj_queue);
 				if (freed) {
+					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Queued freed object, queue size now: %zu/%zu\n", 
+						capture->freeobj_queue.count, capture->freeobj_queue.capacity);
 					// Write directly to the allocated space
 					freed->klass = klass;
 					freed->allocations = allocations;
 					freed->state = state;
 					
-					// Trigger postponed job to process the queue after GC
+					// Trigger postponed job to process both queues after GC
+					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Triggering postponed job to process queues after GC\n");
 					rb_postponed_job_trigger(capture->postponed_job_handle);
+				} else {
+					if (DEBUG_EVENT_QUEUES) fprintf(stderr, "Failed to queue freed object, out of memory\n");
 				}
 				// If push failed (out of memory), silently drop this freeobj event
 			}
@@ -358,7 +440,12 @@ static void Memory_Profiler_Capture_event_callback(VALUE data, void *ptr) {
 	if (!klass) return;
 	
 	if (DEBUG) {
-		const char *klass_name = rb_class2name(klass);
+		// In events other than NEWOBJ, we are unable to allocate objects (due to GC), so we simply say "ignored":
+		const char *klass_name = "ignored";
+		if (event_flag == RUBY_INTERNAL_EVENT_NEWOBJ) {
+			klass_name = rb_class2name(klass);
+		}
+		
 		fprintf(stderr, "Memory_Profiler_Capture_event_callback: %s, Object: %p, Class: %p (%s)\n", event_flag_name(event_flag), (void *)object, (void *)klass, klass_name);
 	}
 	
@@ -388,14 +475,15 @@ static VALUE Memory_Profiler_Capture_alloc(VALUE klass) {
 	
 	capture->enabled = 0;
 	
-	// Initialize the freed object queue
-	Memory_Profiler_Queue_initialize(&capture->freed_queue, sizeof(struct Memory_Profiler_Queue_Item));
+	// Initialize both queues
+	Memory_Profiler_Queue_initialize(&capture->newobj_queue, sizeof(struct Memory_Profiler_Newobj_Queue_Item));
+	Memory_Profiler_Queue_initialize(&capture->freeobj_queue, sizeof(struct Memory_Profiler_Freeobj_Queue_Item));
 	
-	// Pre-register the postponed job for processing freed objects
-	// The job will be triggered whenever we queue freed objects during GC
+	// Pre-register the postponed job for processing both queues
+	// The job will be triggered whenever we queue newobj or freeobj events
 	capture->postponed_job_handle = rb_postponed_job_preregister(
 		0, // flags
-		Memory_Profiler_Capture_process_freed_queue,
+		Memory_Profiler_Capture_process_queues,
 		(void *)obj
 	);
 	
@@ -449,6 +537,7 @@ static VALUE Memory_Profiler_Capture_stop(VALUE self) {
 // Add a class to track with optional callback
 // Usage: track(klass) or track(klass) { |obj, klass| ... }
 // Callback can call caller_locations with desired depth
+// Returns the Allocations object for the tracked class
 static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 	struct Memory_Profiler_Capture *capture;
 	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
@@ -457,8 +546,10 @@ static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 	rb_scan_args(argc, argv, "1&", &klass, &callback);
 		
 	st_data_t allocations_data;
+	VALUE allocations;
+	
 	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
-		VALUE allocations = (VALUE)allocations_data;
+		allocations = (VALUE)allocations_data;
 		struct Memory_Profiler_Capture_Allocations *record = Memory_Profiler_Allocations_get(allocations);
 		RB_OBJ_WRITE(self, &record->callback, callback);
 	} else {
@@ -469,7 +560,7 @@ static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 		record->object_states = NULL;
 		
 		// Wrap the record in a VALUE
-		VALUE allocations = Memory_Profiler_Allocations_wrap(record);
+		allocations = Memory_Profiler_Allocations_wrap(record);
 		
 		st_insert(capture->tracked_classes, (st_data_t)klass, (st_data_t)allocations);
 		// Notify GC about the class VALUE stored as key in the table
@@ -482,7 +573,7 @@ static VALUE Memory_Profiler_Capture_track(int argc, VALUE *argv, VALUE self) {
 		}
 	}
 	
-	return self;
+	return allocations;
 }
 
 // Stop tracking a class
@@ -572,6 +663,19 @@ static VALUE Memory_Profiler_Capture_each(VALUE self) {
 	return self;
 }
 
+// Get allocations for a specific class
+static VALUE Memory_Profiler_Capture_aref(VALUE self, VALUE klass) {
+	struct Memory_Profiler_Capture *capture;
+	TypedData_Get_Struct(self, struct Memory_Profiler_Capture, &Memory_Profiler_Capture_type, capture);
+	
+	st_data_t allocations_data;
+	if (st_lookup(capture->tracked_classes, (st_data_t)klass, &allocations_data)) {
+		return (VALUE)allocations_data;
+	}
+	
+	return Qnil;
+}
+
 void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 {
 	// Initialize event symbols
@@ -591,6 +695,7 @@ void Init_Memory_Profiler_Capture(VALUE Memory_Profiler)
 	rb_define_method(Memory_Profiler_Capture, "tracking?", Memory_Profiler_Capture_tracking_p, 1);
 	rb_define_method(Memory_Profiler_Capture, "count_for", Memory_Profiler_Capture_count_for, 1);
 	rb_define_method(Memory_Profiler_Capture, "each", Memory_Profiler_Capture_each, 0);
+	rb_define_method(Memory_Profiler_Capture, "[]", Memory_Profiler_Capture_aref, 1);
 	rb_define_method(Memory_Profiler_Capture, "clear", Memory_Profiler_Capture_clear, 0);
 	
 	// Initialize Allocations class

data/lib/memory/profiler/sampler.rb

@@ -141,7 +141,7 @@ module Memory
 					if sample.sample!(count)
 						# Check if we should enable detailed tracking
 						if sample.increases >= @increases_threshold && !@call_trees.key?(klass)
-							track_with_analysis_internal(klass, allocations)
+							track(klass, allocations)
 						end
 						
 						# Notify about growth if block given
@@ -150,13 +150,19 @@ module Memory
 				end
 			end
 			
-			# Internal: Enable tracking with analysis using allocations object
-			private def track_with_analysis_internal(klass, allocations)
+			# Start tracking with call path analysis.
+			#
+			# @parameter klass [Class] The class to track with detailed analysis.
+			def track(klass, allocations = nil)
+				# Track the class and get the allocations object
+				allocations ||= @capture.track(klass)
+				
+				# Set up call tree for this class
 				tree = @call_trees[klass] = CallTree.new
 				depth = @depth
 				filter = @filter
 				
-				# Register callback on allocations object with new signature:
+				# Register callback on allocations object:
 				# - On :newobj - returns state (leaf node) which C extension stores
 				# - On :freeobj - receives state back from C extension
 				allocations.track do |klass, event, state|
@@ -166,43 +172,16 @@ module Memory
 						locations = caller_locations(1, depth)
 						filtered = locations.select(&filter)
 						unless filtered.empty?
-							# Record returns the leaf node - return it so C can store it
+							# Record returns the leaf node - return it so C can store it:
 							tree.record(filtered)
 						end
-						# Return nil or the node - C will store whatever we return
+						# Return nil or the node - C will store whatever we return.
 					when :freeobj
-						# Decrement using the state (leaf node) passed back from C
-						if state
-							state.decrement_path!
-						end
+						# Decrement using the state (leaf node) passed back from then native extension:
+						state&.decrement_path!
 					end
 				rescue Exception => error
-					warn "Error in track_with_analysis_internal: #{error.message}\n#{error.backtrace.join("\n")}"
-				end
-			end
-			
-			# Start tracking allocations for a class (count only).
-			def track(klass)
-				return if @capture.tracking?(klass)
-				
-				@capture.track(klass)
-			end
-			
-			# Start tracking with call path analysis.
-			#
-			# @parameter klass [Class] The class to track with detailed analysis.
-			def track_with_analysis(klass)
-				# Track the class if not already tracked
-				unless @capture.tracking?(klass)
-					@capture.track(klass)
-				end
-				
-				# Enable analysis by setting callback on the allocations object
-				@capture.each do |tracked_klass, allocations|
-					if tracked_klass == klass
-						track_with_analysis_internal(klass, allocations)
-						break
-					end
+					warn "Error in allocation tracking: #{error.message}\n#{error.backtrace.join("\n")}"
 				end
 			end
 			
@@ -280,11 +259,7 @@ module Memory
 			private
 			
 			def default_filter
-				->(location) {path = location.path
-																		!path.include?("/gems/") && 
-																							!path.include?("/ruby/") &&
-																							!path.start_with?("(eval)")
-				}
+				->(location) {!location.path.match?(%r{/(gems|ruby)/|\A\(eval\)})}
 			end
 		end
 	end

data/lib/memory/profiler/version.rb

@@ -7,7 +7,7 @@
 module Memory
 	# @namespace
 	module Profiler
-		VERSION = "1.1.3"
+		VERSION = "1.1.5"
 	end
 end
 

data/readme.md

@@ -22,9 +22,13 @@ Please see the [project documentation](https://socketry.github.io/memory-profile
 
 Please see the [project releases](https://socketry.github.io/memory-profiler/releases/index) for all releases.
 
+### v1.1.5
+
+  - Use queue for `newobj` too to avoid invoking user code during object allocation.
+
 ### v1.1.2
 
-    - Fix handling of GC compaction (I hope).
+  - Fix handling of GC compaction (I hope).
 
 ### v0.1.0
 

data/releases.md

@@ -1,8 +1,12 @@
 # Releases
 
+## v1.1.5
+
+  - Use queue for `newobj` too to avoid invoking user code during object allocation.
+
 ## v1.1.2
 
-    - Fix handling of GC compaction (I hope).
+  - Fix handling of GC compaction (I hope).
 
 ## v0.1.0
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memory-profiler
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.5
 platform: ruby
 authors:
 - Samuel Williams
@@ -74,7 +74,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="