Improve heap profile memory usage by lazily loading js objects

binding.gyp

@@ -18,7 +18,8 @@
                             "bindings/thread-cpu-clock.cc",
                             "bindings/translate-heap-profile.cc",
                             "bindings/translate-time-profile.cc",
-                            "bindings/binding.cc"
+                            "bindings/binding.cc",
+                            "bindings/allocation-profile-node.cc"
                         ],
                         "include_dirs": [
                             "bindings",
@@ -42,6 +43,7 @@
                             "bindings/translate-heap-profile.cc",
                             "bindings/translate-time-profile.cc",
                             "bindings/test/binding.cc",
+                            "bindings/allocation-profile-node.cc"
                         ],
                         "include_dirs": [
                             "bindings",

bindings/allocation-profile-node.cc

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2026 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "allocation-profile-node.hh"
+#include "per-isolate-data.hh"
+
+using namespace v8;
+
+namespace dd {
+
+template <typename F>
+void AllocationProfileNodeView::mapAllocationProfileNode(
+    const Nan::PropertyCallbackInfo<Value>& info, F&& mapper) {
+  auto* node = static_cast<AllocationProfile::Node*>(
+      Nan::GetInternalFieldPointer(info.Holder(), 0));
+  info.GetReturnValue().Set(mapper(node));
+}
+
+NAN_MODULE_INIT(AllocationProfileNodeView::Init) {
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>();
+  tpl->SetClassName(Nan::New("AllocationProfileNode").ToLocalChecked());
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  auto inst = tpl->InstanceTemplate();
+  Nan::SetAccessor(inst, Nan::New("name").ToLocalChecked(), GetName);
+  Nan::SetAccessor(
+      inst, Nan::New("scriptName").ToLocalChecked(), GetScriptName);
+  Nan::SetAccessor(inst, Nan::New("scriptId").ToLocalChecked(), GetScriptId);
+  Nan::SetAccessor(
+      inst, Nan::New("lineNumber").ToLocalChecked(), GetLineNumber);
+  Nan::SetAccessor(
+      inst, Nan::New("columnNumber").ToLocalChecked(), GetColumnNumber);
+  Nan::SetAccessor(
+      inst, Nan::New("allocations").ToLocalChecked(), GetAllocations);
+  Nan::SetAccessor(inst, Nan::New("children").ToLocalChecked(), GetChildren);
+
+  PerIsolateData::For(Isolate::GetCurrent())
+      ->AllocationNodeConstructor()
+      .Reset(Nan::GetFunction(tpl).ToLocalChecked());
+}
+
+Local<Object> AllocationProfileNodeView::New(AllocationProfile::Node* node) {
+  auto* isolate = Isolate::GetCurrent();
+
+  Local<Function> constructor =
+      Nan::New(PerIsolateData::For(isolate)->AllocationNodeConstructor());
+
+  Local<Object> obj = Nan::NewInstance(constructor).ToLocalChecked();
+
+  Nan::SetInternalFieldPointer(obj, 0, node);
+
+  return obj;
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetName) {
+  mapAllocationProfileNode(
+      info, [](AllocationProfile::Node* node) { return node->name; });
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetScriptName) {
+  mapAllocationProfileNode(
+      info, [](AllocationProfile::Node* node) { return node->script_name; });
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetScriptId) {
+  mapAllocationProfileNode(
+      info, [](AllocationProfile::Node* node) { return node->script_id; });
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetLineNumber) {
+  mapAllocationProfileNode(
+      info, [](AllocationProfile::Node* node) { return node->line_number; });
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetColumnNumber) {
+  mapAllocationProfileNode(
+      info, [](AllocationProfile::Node* node) { return node->column_number; });
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetAllocations) {
+  mapAllocationProfileNode(info, [](AllocationProfile::Node* node) {
+    auto* isolate = Isolate::GetCurrent();
+    auto context = isolate->GetCurrentContext();
+
+    const auto& allocations = node->allocations;
+    Local<Array> arr = Array::New(isolate, allocations.size());
+    auto sizeBytes = String::NewFromUtf8Literal(isolate, "sizeBytes");
+    auto count = String::NewFromUtf8Literal(isolate, "count");
+
+    for (size_t i = 0; i < allocations.size(); i++) {
+      const auto& alloc = allocations[i];
+      Local<Object> alloc_obj = Object::New(isolate);
+      Nan::Set(alloc_obj,
+               sizeBytes,
+               Number::New(isolate, static_cast<double>(alloc.size)));
+      Nan::Set(alloc_obj,
+               count,
+               Number::New(isolate, static_cast<double>(alloc.count)));
+      arr->Set(context, i, alloc_obj).Check();
+    }
+    return arr;
+  });
+}
+
+NAN_GETTER(AllocationProfileNodeView::GetChildren) {
+  mapAllocationProfileNode(info, [](AllocationProfile::Node* node) {
+    auto* isolate = Isolate::GetCurrent();
+    auto context = isolate->GetCurrentContext();
+
+    const auto& children = node->children;
+    Local<Array> arr = Array::New(isolate, children.size());
+    for (size_t i = 0; i < children.size(); i++) {
+      arr->Set(context, i, AllocationProfileNodeView::New(children[i])).Check();
+    }
+    return arr;
+  });
+}
+
+}  // namespace dd

bindings/allocation-profile-node.hh

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2026 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <nan.h>
+#include <v8-profiler.h>
+
+namespace dd {
+
+class AllocationProfileNodeView {
+ public:
+  static NAN_MODULE_INIT(Init);
+
+  static v8::Local<v8::Object> New(v8::AllocationProfile::Node* node);
+
+ private:
+  template <typename F>
+  static void mapAllocationProfileNode(
+      const Nan::PropertyCallbackInfo<v8::Value>& info, F&& mapper);
+
+  static NAN_GETTER(GetName);
+  static NAN_GETTER(GetScriptName);
+  static NAN_GETTER(GetScriptId);
+  static NAN_GETTER(GetLineNumber);
+  static NAN_GETTER(GetColumnNumber);
+  static NAN_GETTER(GetAllocations);
+  static NAN_GETTER(GetChildren);
+};
+
+}  // namespace dd

bindings/binding.cc

@@ -18,6 +18,7 @@
 #include <node.h>
 #include <v8.h>
 
+#include "allocation-profile-node.hh"
 #include "profilers/heap.hh"
 #include "profilers/wall.hh"
 
@@ -47,6 +48,7 @@ NODE_MODULE_INIT(/* exports, module, context */) {
 #pragma GCC diagnostic pop
 #endif
 
+  dd::AllocationProfileNodeView::Init(exports);
   dd::HeapProfiler::Init(exports);
   dd::WallProfiler::Init(exports);
   Nan::SetMethod(exports, "getNativeThreadId", GetNativeThreadId);

bindings/per-isolate-data.cc

@@ -52,6 +52,10 @@ Nan::Global<v8::Function>& PerIsolateData::WallProfilerConstructor() {
   return wall_profiler_constructor;
 }
 
+Nan::Global<v8::Function>& PerIsolateData::AllocationNodeConstructor() {
+  return allocation_node_constructor;
+}
+
 std::shared_ptr<HeapProfilerState>& PerIsolateData::GetHeapProfilerState() {
   return heap_profiler_state;
 }

bindings/per-isolate-data.hh

@@ -28,6 +28,7 @@ struct HeapProfilerState;
 class PerIsolateData {
  private:
   Nan::Global<v8::Function> wall_profiler_constructor;
+  Nan::Global<v8::Function> allocation_node_constructor;
   std::shared_ptr<HeapProfilerState> heap_profiler_state;
 
   PerIsolateData() {}
@@ -36,6 +37,7 @@ class PerIsolateData {
   static PerIsolateData* For(v8::Isolate* isolate);
 
   Nan::Global<v8::Function>& WallProfilerConstructor();
+  Nan::Global<v8::Function>& AllocationNodeConstructor();
   std::shared_ptr<HeapProfilerState>& GetHeapProfilerState();
 };
 

bindings/profilers/heap.cc

@@ -28,6 +28,7 @@
 
 #include <node.h>
 #include <v8-profiler.h>
+#include "allocation-profile-node.hh"
 
 namespace dd {
 
@@ -55,17 +56,6 @@ static size_t NearHeapLimit(void* data,
 static void InterruptCallback(v8::Isolate* isolate, void* data);
 static void AsyncCallback(uv_async_t* handle);
 
-struct Node {
-  using Allocation = v8::AllocationProfile::Allocation;
-  std::string name;
-  std::string script_name;
-  int line_number;
-  int column_number;
-  int script_id;
-  std::vector<std::shared_ptr<Node>> children;
-  std::vector<Allocation> allocations;
-};
-
 enum CallbackMode {
   kNoCallback = 0,
   kAsyncCallback = 1,
@@ -139,73 +129,6 @@ struct HeapProfilerState {
   bool insideCallback = false;
 };
 
-std::shared_ptr<Node> TranslateAllocationProfileToCpp(
-    v8::AllocationProfile::Node* node) {
-  auto new_node = std::make_shared<Node>();
-  new_node->line_number = node->line_number;
-  new_node->column_number = node->column_number;
-  new_node->script_id = node->script_id;
-  Nan::Utf8String name(node->name);
-  new_node->name.assign(*name, name.length());
-  Nan::Utf8String script_name(node->script_name);
-  new_node->script_name.assign(*script_name, script_name.length());
-
-  new_node->children.reserve(node->children.size());
-  for (auto& child : node->children) {
-    new_node->children.push_back(TranslateAllocationProfileToCpp(child));
-  }
-
-  new_node->allocations.reserve(node->allocations.size());
-  for (auto& allocation : node->allocations) {
-    new_node->allocations.push_back(allocation);
-  }
-  return new_node;
-}
-
-v8::Local<v8::Value> TranslateAllocationProfile(Node* node) {
-  v8::Local<v8::Object> js_node = Nan::New<v8::Object>();
-
-  Nan::Set(js_node,
-           Nan::New<v8::String>("name").ToLocalChecked(),
-           Nan::New(node->name).ToLocalChecked());
-  Nan::Set(js_node,
-           Nan::New<v8::String>("scriptName").ToLocalChecked(),
-           Nan::New(node->script_name).ToLocalChecked());
-  Nan::Set(js_node,
-           Nan::New<v8::String>("scriptId").ToLocalChecked(),
-           Nan::New<v8::Integer>(node->script_id));
-  Nan::Set(js_node,
-           Nan::New<v8::String>("lineNumber").ToLocalChecked(),
-           Nan::New<v8::Integer>(node->line_number));
-  Nan::Set(js_node,
-           Nan::New<v8::String>("columnNumber").ToLocalChecked(),
-           Nan::New<v8::Integer>(node->column_number));
-
-  v8::Local<v8::Array> children = Nan::New<v8::Array>(node->children.size());
-  for (size_t i = 0; i < node->children.size(); i++) {
-    Nan::Set(children, i, TranslateAllocationProfile(node->children[i].get()));
-  }
-  Nan::Set(
-      js_node, Nan::New<v8::String>("children").ToLocalChecked(), children);
-  v8::Local<v8::Array> allocations =
-      Nan::New<v8::Array>(node->allocations.size());
-  for (size_t i = 0; i < node->allocations.size(); i++) {
-    v8::AllocationProfile::Allocation alloc = node->allocations[i];
-    v8::Local<v8::Object> js_alloc = Nan::New<v8::Object>();
-    Nan::Set(js_alloc,
-             Nan::New<v8::String>("sizeBytes").ToLocalChecked(),
-             Nan::New<v8::Number>(alloc.size));
-    Nan::Set(js_alloc,
-             Nan::New<v8::String>("count").ToLocalChecked(),
-             Nan::New<v8::Number>(alloc.count));
-    Nan::Set(allocations, i, js_alloc);
-  }
-  Nan::Set(js_node,
-           Nan::New<v8::String>("allocations").ToLocalChecked(),
-           allocations);
-  return js_node;
-}
-
 static void dumpAllocationProfile(FILE* file,
                                   Node* node,
                                   std::string& cur_stack) {
@@ -582,6 +505,35 @@ NAN_METHOD(HeapProfiler::GetAllocationProfile) {
   info.GetReturnValue().Set(TranslateAllocationProfile(root));
 }
 
+// mapAllocationProfile(callback): callback result
+NAN_METHOD(HeapProfiler::MapAllocationProfile) {
+  if (info.Length() < 1 || !info[0]->IsFunction()) {
+    return Nan::ThrowTypeError("mapAllocationProfile requires a callback");
+  }
+  auto isolate = info.GetIsolate();
+  auto callback = info[0].As<v8::Function>();
+
+  std::unique_ptr<v8::AllocationProfile> profile(
+      isolate->GetHeapProfiler()->GetAllocationProfile());
+
+  if (!profile) {
+    return Nan::ThrowError("Heap profiler is not enabled.");
+  }
+
+  auto state = PerIsolateData::For(isolate)->GetHeapProfilerState();
+  if (state) {
+    state->OnNewProfile();
+  }
+
+  auto root = AllocationProfileNodeView::New(profile->GetRootNode());
+  v8::Local<v8::Value> argv[] = {root};
+  auto result =
+      Nan::Call(callback, isolate->GetCurrentContext()->Global(), 1, argv);
+  if (!result.IsEmpty()) {
+    info.GetReturnValue().Set(result.ToLocalChecked());
+  }
+}
+
 NAN_METHOD(HeapProfiler::MonitorOutOfMemory) {
   if (info.Length() != 7) {
     return Nan::ThrowTypeError("MonitorOOMCondition must have 7 arguments.");
@@ -645,6 +597,7 @@ NAN_MODULE_INIT(HeapProfiler::Init) {
   Nan::SetMethod(
       heapProfiler, "stopSamplingHeapProfiler", StopSamplingHeapProfiler);
   Nan::SetMethod(heapProfiler, "getAllocationProfile", GetAllocationProfile);
+  Nan::SetMethod(heapProfiler, "mapAllocationProfile", MapAllocationProfile);
   Nan::SetMethod(heapProfiler, "monitorOutOfMemory", MonitorOutOfMemory);
   Nan::Set(target,
            Nan::New<v8::String>("heapProfiler").ToLocalChecked(),

bindings/profilers/heap.hh

@@ -34,6 +34,10 @@ class HeapProfiler {
   // getAllocationProfile(): AllocationProfileNode
   static NAN_METHOD(GetAllocationProfile);
 
+  // Signature:
+  // mapAllocationProfile(callback): callback result
+  static NAN_METHOD(MapAllocationProfile);
+
   static NAN_METHOD(MonitorOutOfMemory);
 
   static NAN_MODULE_INIT(Init);