@datadog/pprof 0.2.1 → 0.5.0

package/bindings/location.cc

@@ -0,0 +1,117 @@
+#include <node.h>
+
+#include "per-isolate-data.hh"
+#include "location.hh"
+
+namespace dd {
+
+Location::Location(v8::Isolate* isolate,
+                   std::shared_ptr<CodeEventRecord> code_event_record)
+  : code_event_record(std::move(code_event_record)) {}
+
+Location* Location::New(v8::Isolate* isolate,
+                        std::shared_ptr<CodeEventRecord> code_event_record) {
+  auto per_isolate = PerIsolateData::For(isolate);
+  v8::Local<v8::Function> cons = Nan::New(
+      per_isolate->LocationConstructor());
+  auto inst = Nan::NewInstance(cons, 0, {}).ToLocalChecked();
+
+  auto location = new Location(isolate, std::move(code_event_record));
+  location->Wrap(inst);
+  return location;
+}
+
+std::shared_ptr<CodeEventRecord> Location::GetCodeEventRecord() {
+  return code_event_record;
+}
+
+NAN_GETTER(Location::GetScriptId) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetScriptId(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetAddress) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetAddress(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetPreviousAddress) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetPreviousAddress(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetSize) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetSize(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetFunctionName) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetFunctionName(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetScriptName) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetScriptName(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetLine) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetLine(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetColumn) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetColumn(info.GetIsolate()));
+}
+
+NAN_GETTER(Location::GetComment) {
+  Location* wrap = Nan::ObjectWrap::Unwrap<Location>(info.Holder());
+  info.GetReturnValue().Set(wrap->GetCodeEventRecord()->GetComment(info.GetIsolate()));
+}
+
+NAN_MODULE_INIT(Location::Init) {
+  auto class_name = Nan::New<v8::String>("CodeEvent")
+      .ToLocalChecked();
+
+  auto tpl = Nan::New<v8::FunctionTemplate>(nullptr);
+  tpl->SetClassName(class_name);
+  tpl->InstanceTemplate()
+      ->SetInternalFieldCount(1);
+
+  auto proto = tpl->InstanceTemplate();
+
+  Nan::SetAccessor(proto,
+      Nan::New("scriptId").ToLocalChecked(),
+      GetScriptId);
+  Nan::SetAccessor(proto,
+      Nan::New("address").ToLocalChecked(),
+      GetAddress);
+  Nan::SetAccessor(proto,
+      Nan::New("previousAddress").ToLocalChecked(),
+      GetPreviousAddress);
+  Nan::SetAccessor(proto,
+      Nan::New("size").ToLocalChecked(),
+      GetSize);
+  Nan::SetAccessor(proto,
+      Nan::New("line").ToLocalChecked(),
+      GetLine);
+  Nan::SetAccessor(proto,
+      Nan::New("column").ToLocalChecked(),
+      GetColumn);
+  Nan::SetAccessor(proto,
+      Nan::New("comment").ToLocalChecked(),
+      GetComment);
+  Nan::SetAccessor(proto,
+      Nan::New("functionName").ToLocalChecked(),
+      GetFunctionName);
+  Nan::SetAccessor(proto,
+      Nan::New("scriptName").ToLocalChecked(),
+      GetScriptName);
+
+  auto fn = Nan::GetFunction(tpl).ToLocalChecked();
+  auto per_isolate = PerIsolateData::For(target->GetIsolate());
+  per_isolate->LocationConstructor().Reset(fn);
+}
+
+}; // namespace dd

package/bindings/location.hh

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+
+#include <nan.h>
+#include <node_object_wrap.h> // cppcheck-suppress missingIncludeSystem
+
+#include "code-event-record.hh"
+
+namespace dd {
+
+class Location : public Nan::ObjectWrap {
+ private:
+  std::shared_ptr<CodeEventRecord> code_event_record;
+
+ public:
+  explicit Location(v8::Isolate* isolate,
+                    std::shared_ptr<CodeEventRecord> code_event_record);
+
+  static Location* New(v8::Isolate* isolate,
+                       std::shared_ptr<CodeEventRecord> code_event_record);
+
+  std::shared_ptr<CodeEventRecord> GetCodeEventRecord();
+
+  static NAN_GETTER(GetScriptId);
+  static NAN_GETTER(GetAddress);
+  static NAN_GETTER(GetPreviousAddress);
+  static NAN_GETTER(GetSize);
+  static NAN_GETTER(GetLine);
+  static NAN_GETTER(GetColumn);
+  static NAN_GETTER(GetFunctionName);
+  static NAN_GETTER(GetScriptName);
+  static NAN_GETTER(GetComment);
+
+  static NAN_MODULE_INIT(Init);
+
+  friend class CodeMap;
+
+  using Nan::ObjectWrap::Ref;
+  using Nan::ObjectWrap::Unref;
+};
+
+}; // namespace dd

package/bindings/per-isolate-data.cc

@@ -0,0 +1,42 @@
+#include <unordered_map>
+
+#include "per-isolate-data.hh"
+
+namespace dd {
+
+static std::unordered_map<v8::Isolate*, PerIsolateData> per_isolate_data_;
+
+PerIsolateData::PerIsolateData(v8::Isolate* isolate)
+  : isolate_(isolate) {}
+
+PerIsolateData* PerIsolateData::For(v8::Isolate* isolate) {
+  auto maybe = per_isolate_data_.find(isolate);
+  if (maybe != per_isolate_data_.end()) {
+    return &maybe->second;
+  }
+
+  per_isolate_data_.emplace(std::make_pair(isolate, PerIsolateData(isolate)));
+
+  auto pair = per_isolate_data_.find(isolate);
+  auto perIsolateData = &pair->second;
+
+  node::AddEnvironmentCleanupHook(isolate, [](void* data) {
+    per_isolate_data_.erase(static_cast<v8::Isolate*>(data));
+  }, isolate);
+
+  return perIsolateData;
+}
+
+Nan::Global<v8::Function>& PerIsolateData::CpuProfilerConstructor() {
+  return cpu_profiler_constructor;
+}
+
+Nan::Global<v8::Function>& PerIsolateData::LocationConstructor() {
+  return location_constructor;
+}
+
+Nan::Global<v8::Function>& PerIsolateData::SampleConstructor() {
+  return sample_constructor;
+}
+
+} // namespace dd

package/bindings/per-isolate-data.hh

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <nan.h>
+#include <node.h>
+#include <v8.h>
+
+namespace dd {
+
+class PerIsolateData {
+ private:
+  v8::Isolate* isolate_;
+  Nan::Global<v8::Function> cpu_profiler_constructor;
+  Nan::Global<v8::Function> location_constructor;
+  Nan::Global<v8::Function> sample_constructor;
+
+  PerIsolateData(v8::Isolate* isolate);
+
+ public:
+  static PerIsolateData* For(v8::Isolate* isolate);
+
+  Nan::Global<v8::Function>& CpuProfilerConstructor();
+  Nan::Global<v8::Function>& LocationConstructor();
+  Nan::Global<v8::Function>& SampleConstructor();
+};
+
+} // namespace dd

package/bindings/profilers/cpu.cc

@@ -0,0 +1,285 @@
+#include <queue>
+
+#include <v8-profiler.h>
+#include <v8.h>
+#include <node.h>
+#include <uv.h>
+
+#include "../per-isolate-data.hh"
+#include "../location.hh"
+#include "cpu.hh"
+
+namespace dd {
+
+CpuProfiler::CpuProfiler()
+  : isolate_(v8::Isolate::GetCurrent()),
+    async(new uv_async_t()),
+    code_map(CodeMap::For(isolate_)),
+    samples(Nan::New<v8::Array>()),
+    sampler_running(false) {
+  // TODO: Move symbolizer worker to a separate class?
+  // Initialize libuv async worker to process samples when JS thread is idle
+  uv_async_init(Nan::GetCurrentEventLoop(), async, Run);
+  // Unref the async worker so it won't hold the loop open when there are no
+  // other tasks. This allows it to clean itself up automatically.
+  uv_unref(reinterpret_cast<uv_handle_t*>(async));
+  // The async worker needs a reference to the profiler instance so it can get
+  // the pending sample and the vector to push symbolized samples to.
+  async->data = static_cast<void*>(this);
+  uv_sem_init(&sampler_thread_done, 1);
+}
+
+CpuProfiler::~CpuProfiler() {
+  uv_close(reinterpret_cast<uv_handle_t*>(async),
+    [](uv_handle_t* handle){
+      delete reinterpret_cast<uv_handle_t*>(handle);
+    });
+  Stop();
+
+  uv_sem_wait(&sampler_thread_done);
+  uv_sem_destroy(&sampler_thread_done);
+}
+
+CpuProfiler* CpuProfiler::New() {
+  auto isolate = v8::Isolate::GetCurrent();
+  auto per_isolate = PerIsolateData::For(isolate);
+  v8::Local<v8::Function> cons = Nan::New(
+      per_isolate->CpuProfilerConstructor());
+  auto inst = Nan::NewInstance(cons, 0, {}).ToLocalChecked();
+  return Nan::ObjectWrap::Unwrap<CpuProfiler>(inst);
+}
+
+v8::Local<v8::Number> CpuProfiler::GetFrequency() {
+  return Nan::New<v8::Number>(frequency);
+}
+
+// NOTE: last sample must be a unique_ptr to ensure it is cleaned up
+// when no longer referenced. However when `ProcessSample()` is called
+// it will be released from the unique_ptr as it will become owned by
+// the JavaScript thread which creates a corresponding handle object,
+// making it garbage-collectable.
+void CpuProfiler::SetLastSample(std::unique_ptr<Sample> sample) {
+  lastSample = std::move(sample);
+}
+
+// NOTE: For test/debug purposes only
+Sample* CpuProfiler::GetLastSample() {
+  return lastSample.get();
+}
+
+void CpuProfiler::CaptureSample(v8::Isolate* isolate) {
+  const std::lock_guard<std::mutex> lock(mutex);
+  auto diff = cpu_time.Diff();
+  SetLastSample(
+    std::make_unique<Sample>(isolate, labels_, diff));
+}
+
+// TODO: Make sampler thread a separate class?
+void CpuProfiler::SamplerThread(double hz) {
+  using hrc = std::chrono::high_resolution_clock;
+  std::chrono::duration<double> interval(1.0 / hz);
+  while (sampler_running) {
+    isolate_->RequestInterrupt([](v8::Isolate* isolate, void* data) {
+      auto profiler = static_cast<CpuProfiler*>(data);
+      profiler->CaptureSample(isolate);
+
+      // Notify symbolizer worker that we have a new sample
+      uv_async_send(profiler->async);
+    }, this);
+
+    std::this_thread::sleep_for(interval);
+  }
+  uv_sem_post(&sampler_thread_done);
+}
+
+void CpuProfiler::ProcessSample() {
+  v8::HandleScope scope(isolate_);
+
+  Sample* sample;
+  {
+    const std::lock_guard<std::mutex> lock(mutex);
+    sample = lastSample.release();
+  }
+
+  if (!sample) return;
+  if (!sample->Symbolize(code_map)->Length()) {
+    delete sample;
+    return;
+  }
+
+  // Append the newly processed sample to the samples array
+  auto arr = samples.Get(isolate_);
+  arr->Set(isolate_->GetCurrentContext(), arr->Length(),
+    sample->ToObject(isolate_)).Check();
+}
+
+void CpuProfiler::Run(uv_async_t* handle) {
+  auto profiler = static_cast<CpuProfiler*>(handle->data);
+  profiler->ProcessSample();
+}
+
+void CpuProfiler::Start(double hz) {
+  if (sampler_running) return;
+
+  frequency = hz;
+  sampler_running = true;
+  uv_sem_init(&sampler_thread_done, 0);
+  uv_thread_create(&sampler_thread, [](void* arg) {
+    auto profiler = static_cast<CpuProfiler*>(arg);
+    profiler->SamplerThread(profiler->frequency);
+  }, this);
+  start_time = uv_hrtime();
+  code_map->Enable();
+}
+
+void CpuProfiler::Stop() {
+  if (!sampler_running) return;
+
+  frequency = 0;
+  sampler_running = false;
+  code_map->Disable();
+}
+
+v8::Local<v8::Value> CpuProfiler::GetLabels() {
+  const std::lock_guard<std::mutex> lock(mutex);
+  if (!labels_) return Nan::Undefined();
+  return labels_->handle();
+}
+
+void CpuProfiler::SetLabels(v8::Local<v8::Value> value) {
+  const std::lock_guard<std::mutex> lock(mutex);
+  labels_ = std::make_shared<LabelWrap>(value);
+}
+
+uint32_t CpuProfiler::GetSampleCount() {
+  return samples.Get(isolate_)->Length();
+}
+
+// TODO: Probably should make an explicit clear method rather than
+// implicitly clearing whenever getting the samples array
+v8::Local<v8::Array> CpuProfiler::GetSamples() {
+  auto array = samples.Get(isolate_);
+  samples.Reset(Nan::New<v8::Array>());
+  return array;
+}
+
+v8::Local<v8::Value> CpuProfiler::GetProfile() {
+  auto profile = Nan::New<v8::Object>();
+  auto end_time = uv_hrtime();
+
+  Nan::Set(profile,
+           Nan::New("name").ToLocalChecked(),
+           Nan::New("(root)").ToLocalChecked()).Check();
+  Nan::Set(profile,
+           Nan::New("startTime").ToLocalChecked(),
+           v8::BigInt::New(isolate_, start_time)).Check();
+  Nan::Set(profile,
+           Nan::New("endTime").ToLocalChecked(),
+           v8::BigInt::New(isolate_, end_time)).Check();
+  Nan::Set(profile,
+           Nan::New("samples").ToLocalChecked(),
+           GetSamples()).Check();
+
+  start_time = end_time;
+
+  return profile;
+}
+
+NAN_METHOD(CpuProfiler::New) {
+  if (info.IsConstructCall()) {
+    CpuProfiler* profiler = new CpuProfiler();
+    profiler->Wrap(info.This());
+    info.GetReturnValue().Set(info.This());
+  } else {
+    auto per_isolate = PerIsolateData::For(info.GetIsolate());
+    v8::Local<v8::Function> cons = Nan::New(
+        per_isolate->CpuProfilerConstructor());
+    info.GetReturnValue().Set(Nan::NewInstance(cons, 0, {}).ToLocalChecked());
+  }
+}
+
+NAN_GETTER(CpuProfiler::GetFrequency) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  info.GetReturnValue().Set(profiler->GetFrequency());
+}
+
+NAN_METHOD(CpuProfiler::Start) {
+  if (!info[0]->IsNumber()) {
+    Nan::ThrowTypeError("hz is not a number");
+    return;
+  }
+
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  profiler->Start(Nan::To<double>(info[0]).FromJust());
+}
+
+NAN_METHOD(CpuProfiler::Stop) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  profiler->Stop();
+}
+
+NAN_METHOD(CpuProfiler::CaptureSample) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  profiler->CaptureSample(info.GetIsolate());
+}
+
+NAN_METHOD(CpuProfiler::ProcessSample) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  profiler->ProcessSample();
+}
+
+NAN_GETTER(CpuProfiler::GetLabels) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  info.GetReturnValue().Set(profiler->GetLabels());
+}
+
+NAN_SETTER(CpuProfiler::SetLabels) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  profiler->SetLabels(value);
+}
+
+NAN_METHOD(CpuProfiler::GetSamples) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  info.GetReturnValue().Set(profiler->GetSamples());
+}
+
+NAN_METHOD(CpuProfiler::GetProfile) {
+  auto profiler = Nan::ObjectWrap::Unwrap<CpuProfiler>(info.Holder());
+  info.GetReturnValue().Set(profiler->GetProfile());
+}
+
+NAN_MODULE_INIT(CpuProfiler::Init) {
+  Location::Init(target);
+  Sample::Init(target);
+
+  auto class_name = Nan::New<v8::String>("CpuProfiler")
+      .ToLocalChecked();
+
+  auto tpl = Nan::New<v8::FunctionTemplate>(New);
+  tpl->SetClassName(class_name);
+  tpl->InstanceTemplate()
+      ->SetInternalFieldCount(1);
+
+  auto inst = tpl->InstanceTemplate();
+  Nan::SetAccessor(inst,
+    Nan::New("labels").ToLocalChecked(),
+    GetLabels, SetLabels);
+
+  Nan::SetAccessor(inst,
+    Nan::New("frequency").ToLocalChecked(),
+    GetFrequency);
+
+  Nan::SetPrototypeMethod(tpl, "start", Start);
+  Nan::SetPrototypeMethod(tpl, "stop", Stop);
+  Nan::SetPrototypeMethod(tpl, "captureSample", CaptureSample);
+  Nan::SetPrototypeMethod(tpl, "processSample", ProcessSample);
+  Nan::SetPrototypeMethod(tpl, "samples", GetSamples);
+  Nan::SetPrototypeMethod(tpl, "profile", GetProfile);
+
+  auto fn = Nan::GetFunction(tpl).ToLocalChecked();
+  Nan::Set(target, class_name, fn);
+  auto per_isolate = PerIsolateData::For(target->GetIsolate());
+  per_isolate->CpuProfilerConstructor().Reset(fn);
+}
+
+} // namespace dd

package/bindings/profilers/cpu.hh

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <atomic>
+#include <mutex>
+#include <thread>
+#include <chrono>
+
+#include <nan.h>
+
+#include "../code-map.hh"
+#include "../cpu-time.hh"
+#include "../sample.hh"
+#include "../wrap.hh"
+
+namespace dd {
+
+class CpuProfiler : public Nan::ObjectWrap {
+  friend class CodeMap;
+
+ private:
+  v8::Isolate* isolate_;
+  uv_async_t* async;
+  std::shared_ptr<CodeMap> code_map;
+  CpuTime cpu_time;
+  std::unique_ptr<Sample> lastSample;
+  std::shared_ptr<LabelWrap> labels_;
+  double frequency = 0;
+  Nan::Global<v8::Array> samples;
+  std::mutex mutex;
+  uint64_t start_time;
+  uv_sem_t sampler_thread_done;
+  uv_thread_t sampler_thread;
+  std::atomic_bool sampler_running;
+
+ public:
+  CpuProfiler();
+  ~CpuProfiler();
+  static CpuProfiler* New();
+
+  // Disable copies and moves
+  CpuProfiler(const CpuProfiler& other) = delete;
+  CpuProfiler(CpuProfiler&& other) = delete;
+  CpuProfiler& operator=(const CpuProfiler& other) = delete;
+  CpuProfiler& operator=(CpuProfiler&& other) = delete;
+
+  v8::Local<v8::Number> GetFrequency();
+
+  void SetLastSample(std::unique_ptr<Sample> sample);
+  Sample* GetLastSample();
+  void CaptureSample(v8::Isolate* isolate);
+  void SamplerThread(double hz);
+
+  void ProcessSample();
+  static void Run(uv_async_t* handle);
+
+  v8::Local<v8::Value> GetLabels();
+  void SetLabels(v8::Local<v8::Value>);
+  void Start(double hz);
+  void Stop();
+  uint32_t GetSampleCount();
+  v8::Local<v8::Array> GetSamples();
+  v8::Local<v8::Value> GetProfile();
+
+  static NAN_METHOD(New);
+  static NAN_GETTER(GetFrequency);
+  static NAN_GETTER(GetLabels);
+  static NAN_SETTER(SetLabels);
+  static NAN_METHOD(Start);
+  static NAN_METHOD(Stop);
+  static NAN_METHOD(CaptureSample);
+  static NAN_METHOD(ProcessSample);
+  static NAN_METHOD(GetSamples);
+  static NAN_METHOD(GetProfile);
+
+  static NAN_MODULE_INIT(Init);
+};
+
+} // namespace dd

package/bindings/profilers/heap.cc

@@ -0,0 +1,112 @@
+/**
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ *
+ * 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 "heap.hh"
+
+#include <memory>
+
+#include <node.h>
+#include <v8-profiler.h>
+
+using namespace v8;
+
+namespace dd {
+
+Local<Value> TranslateAllocationProfile(AllocationProfile::Node* node) {
+  Local<Object> js_node = Nan::New<Object>();
+
+  Nan::Set(js_node, Nan::New<String>("name").ToLocalChecked(), node->name);
+  Nan::Set(js_node, Nan::New<String>("scriptName").ToLocalChecked(),
+           node->script_name);
+  Nan::Set(js_node, Nan::New<String>("scriptId").ToLocalChecked(),
+           Nan::New<Integer>(node->script_id));
+  Nan::Set(js_node, Nan::New<String>("lineNumber").ToLocalChecked(),
+           Nan::New<Integer>(node->line_number));
+  Nan::Set(js_node, Nan::New<String>("columnNumber").ToLocalChecked(),
+           Nan::New<Integer>(node->column_number));
+
+  Local<Array> children = Nan::New<Array>(node->children.size());
+  for (size_t i = 0; i < node->children.size(); i++) {
+    Nan::Set(children, i, TranslateAllocationProfile(node->children[i]));
+  }
+  Nan::Set(js_node, Nan::New<String>("children").ToLocalChecked(), children);
+  Local<Array> allocations = Nan::New<Array>(node->allocations.size());
+  for (size_t i = 0; i < node->allocations.size(); i++) {
+    AllocationProfile::Allocation alloc = node->allocations[i];
+    Local<Object> js_alloc = Nan::New<Object>();
+    Nan::Set(js_alloc, Nan::New<String>("sizeBytes").ToLocalChecked(),
+             Nan::New<Number>(alloc.size));
+    Nan::Set(js_alloc, Nan::New<String>("count").ToLocalChecked(),
+             Nan::New<Number>(alloc.count));
+    Nan::Set(allocations, i, js_alloc);
+  }
+  Nan::Set(js_node, Nan::New<String>("allocations").ToLocalChecked(),
+           allocations);
+  return js_node;
+}
+
+NAN_METHOD(HeapProfiler::StartSamplingHeapProfiler) {
+  if (info.Length() == 2) {
+    if (!info[0]->IsUint32()) {
+      return Nan::ThrowTypeError("First argument type must be uint32.");
+    }
+    if (!info[1]->IsNumber()) {
+      return Nan::ThrowTypeError("First argument type must be Integer.");
+    }
+
+#if NODE_MODULE_VERSION > NODE_8_0_MODULE_VERSION
+    uint64_t sample_interval = info[0].As<Integer>()->Value();
+    int stack_depth = info[1].As<Integer>()->Value();
+#else
+    uint64_t sample_interval = info[0].As<Integer>()->Uint32Value();
+    int stack_depth = info[1].As<Integer>()->IntegerValue();
+#endif
+
+    info.GetIsolate()->GetHeapProfiler()->StartSamplingHeapProfiler(
+        sample_interval, stack_depth);
+  } else {
+    info.GetIsolate()->GetHeapProfiler()->StartSamplingHeapProfiler();
+  }
+}
+
+// Signature:
+// stopSamplingHeapProfiler()
+NAN_METHOD(HeapProfiler::StopSamplingHeapProfiler) {
+  info.GetIsolate()->GetHeapProfiler()->StopSamplingHeapProfiler();
+}
+
+// Signature:
+// getAllocationProfile(): AllocationProfileNode
+NAN_METHOD(HeapProfiler::GetAllocationProfile) {
+  std::unique_ptr<v8::AllocationProfile> profile(
+      info.GetIsolate()->GetHeapProfiler()->GetAllocationProfile());
+  AllocationProfile::Node* root = profile->GetRootNode();
+  info.GetReturnValue().Set(TranslateAllocationProfile(root));
+}
+
+NAN_MODULE_INIT(HeapProfiler::Init) {
+  v8::Local<v8::Object> heapProfiler = Nan::New<v8::Object>();
+  Nan::SetMethod(heapProfiler, "startSamplingHeapProfiler",
+                 StartSamplingHeapProfiler);
+  Nan::SetMethod(heapProfiler, "stopSamplingHeapProfiler",
+                 StopSamplingHeapProfiler);
+  Nan::SetMethod(heapProfiler, "getAllocationProfile",
+                 GetAllocationProfile);
+  Nan::Set(target, Nan::New<v8::String>("heapProfiler").ToLocalChecked(),
+           heapProfiler);
+}
+
+} // namespace dd