@datadog/pprof 0.5.1 → 1.0.0

package/bindings/profilers/cpu.cc

@@ -1,285 +0,0 @@
-#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

@@ -1,78 +0,0 @@
-#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

@@ -1,112 +0,0 @@
-/**
- * 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

package/bindings/profilers/heap.hh

@@ -1,40 +0,0 @@
-/**
- * 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.
- */
-
-#pragma once
-
-#include <nan.h>
-
-namespace dd {
-
-class HeapProfiler {
- public:
-  // Signature:
-  // startSamplingHeapProfiler()
-  static NAN_METHOD(StartSamplingHeapProfiler);
-
-  // Signature:
-  // stopSamplingHeapProfiler()
-  static NAN_METHOD(StopSamplingHeapProfiler);
-
-  // Signature:
-  // getAllocationProfile(): AllocationProfileNode
-  static NAN_METHOD(GetAllocationProfile);
-
-  static NAN_MODULE_INIT(Init);
-};
-
-} // namespace dd