@datadog/pprof 0.4.0 → 0.5.0

package/binding.gyp

@@ -1,40 +1,136 @@
 {
-  "targets": [
-    {
-      "target_name": "dd-pprof",
-      "sources": [ 
-        "bindings/profiler.cc",
-      ],
-      "include_dirs": ["<!(node -e \"require('nan')\")"],
-        "xcode_settings": {
-          "MACOSX_DEPLOYMENT_TARGET": "10.10",
-          "OTHER_CFLAGS": [
-              "-std=c++14",
-              "-stdlib=libc++",
-              "-Wall",
-              "-Werror",
-              "-Wno-deprecated-declarations",
-          ]
+  "variables": {
+    "asan%": 0,
+    "lsan%": 0,
+    "ubsan%": 0,
+  },
+  "conditions": [
+    ["OS == 'mac'", {
+      "xcode_settings": {
+        "MACOSX_DEPLOYMENT_TARGET": "10.10",
+        'CLANG_CXX_LIBRARY': 'libc++',
+        "OTHER_CFLAGS": [
+          "-std=c++14",
+          "-stdlib=libc++",
+          "-Wall",
+          "-Werror",
+          "-Wno-deprecated-declarations",
+        ]
+      },
+    }],
+    ["OS == 'linux'", {
+      "link_settings": {
+        "libraries": ["-lrt"]
       },
-        "conditions": [
-          ["OS == 'linux'", {
-              "cflags": [
-                  "-std=c++11",
-                  "-Wall",
-                  "-Werror"
-              ],
-              "cflags_cc": [
-                  "-Wno-cast-function-type",
-                  # TODO: Remove when nan is updated to support v18 properly
-                  "-Wno-deprecated-declarations",
-              ]
-          }],
-          ["OS == 'win'", {
-              "cflags": [
-                  "/WX"
-              ]
-          }]
+      "cflags": [
+        "-std=c++14",
+        "-Wall",
+        "-Werror"
+      ],
+      "cflags_cc": [
+        "-Wno-cast-function-type",
+        # TODO: Remove when nan is updated to support v18 properly
+        "-Wno-deprecated-declarations",
+      ]
+    }],
+    ["OS == 'win'", {
+      "cflags": [
+        "/WX"
       ]
+    }],
+    # No macOS support for -fsanitize=leak
+    ["lsan == 'true' and OS != 'mac'", {
+      "cflags+": ["-fsanitize=leak"],
+      "ldflags": ["-fsanitize=leak"],
+    }],
+    ["asan == 'true' and OS != 'mac'", {
+      "cflags+": [
+        "-fno-omit-frame-pointer",
+        "-fsanitize=address",
+        "-fsanitize-address-use-after-scope",
+      ],
+      "cflags!": [ "-fomit-frame-pointer" ],
+      "ldflags": [ "-fsanitize=address" ],
+    }],
+    ["asan == 'true' and OS == 'mac'", {
+      "xcode_settings+": {
+        "OTHER_CFLAGS+": [
+          "-fno-omit-frame-pointer",
+          "-gline-tables-only",
+          "-fsanitize=address",
+        ],
+        "OTHER_CFLAGS!": [
+          "-fomit-frame-pointer",
+        ],
+        "OTHER_LDFLAGS": [
+          "-fsanitize=address",
+        ],
+      },
+    }],
+    # UBSAN
+    ["ubsan == 'true' and OS != 'mac'", {
+      "cflags+": [
+        "-fsanitize=undefined,alignment,bounds",
+        "-fno-sanitize-recover",
+      ],
+      "ldflags": [
+        "-fsanitize=undefined,alignment,bounds"
+      ],
+    }],
+    ["ubsan == 'true' and OS == 'mac'", {
+      "xcode_settings+": {
+        "OTHER_CFLAGS+": [
+          "-fsanitize=undefined,alignment,bounds",
+          "-fno-sanitize-recover",
+        ],
+        "OTHER_LDFLAGS": [
+          "-fsanitize=undefined,alignment,bounds"
+        ],
+      },
+    }],
+  ],
+  "targets": [
+    {
+      "target_name": "dd_pprof",
+      "sources": [
+        "bindings/profilers/cpu.cc",
+        "bindings/profilers/heap.cc",
+        "bindings/profilers/wall.cc",
+        "bindings/code-event-record.cc",
+        "bindings/code-map.cc",
+        "bindings/cpu-time.cc",
+        "bindings/location.cc",
+        "bindings/per-isolate-data.cc",
+        "bindings/sample.cc",
+        "bindings/binding.cc",
+      ],
+      "include_dirs": [
+        "<!(node -e \"require('nan')\")",
+      ],
+    },
+    {
+      "target_name": "test_dd_pprof",
+      "sources": [
+        "bindings/profilers/cpu.cc",
+        "bindings/profilers/heap.cc",
+        "bindings/profilers/wall.cc",
+        "bindings/code-event-record.cc",
+        "bindings/code-map.cc",
+        "bindings/cpu-time.cc",
+        "bindings/location.cc",
+        "bindings/per-isolate-data.cc",
+        "bindings/sample.cc",
+        "bindings/test/binding.cc",
+        "bindings/test/profilers/cpu.test.cc",
+        "bindings/test/code-event-record.test.cc",
+        "bindings/test/code-map.test.cc",
+        "bindings/test/cpu-time.test.cc",
+        "bindings/test/location.test.cc",
+        "bindings/test/sample.test.cc",
+      ],
+      "include_dirs": [
+        "<!(node -e \"require('nan')\")",
+      ],
     },
   ]
 }

package/bindings/binding.cc

@@ -0,0 +1,13 @@
+#include "node.h"
+#include "nan.h"
+#include "v8.h"
+
+#include "profilers/cpu.hh"
+#include "profilers/heap.hh"
+#include "profilers/wall.hh"
+
+NODE_MODULE_INIT(/* exports, module, context */) {
+  dd::CpuProfiler::Init(exports);
+  dd::HeapProfiler::Init(exports);
+  dd::WallProfiler::Init(exports);
+}

package/bindings/code-event-record.cc

@@ -0,0 +1,115 @@
+#include <node.h>
+
+#include "code-event-record.hh"
+
+namespace dd {
+
+  CodeEventRecord::CodeEventRecord(v8::Isolate *isolate,
+                                   uintptr_t address,
+                                   uintptr_t previousAddress,
+                                   size_t size,
+                                   int line,
+                                   int column,
+                                   std::string comment,
+                                   std::string functionName,
+                                   std::string scriptName)
+      : address(address),
+        previousAddress(previousAddress),
+        size(size),
+        line(line),
+        column(column),
+        comment(comment),
+        functionName(functionName),
+        scriptName(scriptName) {}
+
+std::string safe_string(const char* maybe_string) {
+  return maybe_string == nullptr ? "" : maybe_string;
+}
+
+std::string safe_string(v8::Isolate* isolate, v8::Local<v8::String> maybe_string) {
+  auto len = maybe_string->Utf8Length(isolate);
+  std::string buffer(len + 1, 0);
+  maybe_string->WriteUtf8(isolate, &buffer[0], len + 1);
+  return std::string(buffer.c_str());
+}
+
+CodeEventRecord::CodeEventRecord(v8::Isolate* isolate, v8::CodeEvent* code_event)
+  : CodeEventRecord(
+      isolate,
+      code_event->GetCodeStartAddress(),
+  // CodeEvent::GetPreviousCodeStartAddress didn't exist until Node.js 13.
+  #if NODE_MODULE_VERSION > 79
+      code_event->GetPreviousCodeStartAddress(),
+  #else
+      0,
+  #endif
+      code_event->GetCodeSize(),
+      code_event->GetScriptLine(),
+      code_event->GetScriptColumn(),
+      safe_string(code_event->GetComment()),
+      safe_string(isolate, code_event->GetFunctionName()),
+      safe_string(isolate, code_event->GetScriptName())
+    ) {}
+
+void CodeEventRecord::SetScriptId(int _scriptId) {
+  scriptId = _scriptId;
+}
+
+v8::Local<v8::Integer> CodeEventRecord::GetScriptId(v8::Isolate* isolate) {
+  return v8::Integer::New(isolate, scriptId);
+}
+
+v8::Local<v8::Integer> CodeEventRecord::GetAddress(v8::Isolate* isolate) {
+  return v8::Integer::NewFromUnsigned(isolate, address);
+}
+
+v8::Local<v8::Integer> CodeEventRecord::GetPreviousAddress(v8::Isolate* isolate) {
+  return v8::Integer::NewFromUnsigned(isolate, previousAddress);
+}
+
+v8::Local<v8::Integer> CodeEventRecord::GetSize(v8::Isolate* isolate) {
+  return v8::Integer::NewFromUnsigned(isolate, size);
+}
+
+v8::Local<v8::Value> CodeEventRecord::GetFunctionName(v8::Isolate* isolate) {
+  if (functionName.empty()) {
+    return v8::Undefined(isolate);
+  }
+  return Nan::New(functionName).ToLocalChecked();
+}
+
+v8::Local<v8::Value> CodeEventRecord::GetScriptName(v8::Isolate* isolate) {
+  if (scriptName.empty()) {
+    return v8::Undefined(isolate);
+  }
+  return Nan::New(scriptName).ToLocalChecked();
+}
+
+v8::Local<v8::Integer> CodeEventRecord::GetLine(v8::Isolate* isolate) {
+  return v8::Integer::New(isolate, line);
+}
+
+v8::Local<v8::Integer> CodeEventRecord::GetColumn(v8::Isolate* isolate) {
+  return v8::Integer::New(isolate, column);
+}
+
+v8::Local<v8::Value> CodeEventRecord::GetComment(v8::Isolate* isolate) {
+  if (comment.empty()) {
+    return v8::Undefined(isolate);
+  }
+  return Nan::New(comment).ToLocalChecked();
+}
+
+bool CodeEventRecord::Equal(const CodeEventRecord* rhs) const {
+  return scriptId == rhs->scriptId &&
+      address == rhs->address &&
+      previousAddress == rhs->previousAddress &&
+      size == rhs->size &&
+      line == rhs->line &&
+      column == rhs->column &&
+      comment == rhs->comment &&
+      functionName == rhs->functionName &&
+      scriptName == rhs->scriptName;
+}
+
+}; // namespace dd

package/bindings/code-event-record.hh

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <string>
+#include <map>
+
+#include <nan.h>
+#include <node_object_wrap.h> // cppcheck-suppress missingIncludeSystem
+#include <v8-profiler.h>
+#include <v8.h>
+
+namespace dd {
+
+class CodeMap;
+
+class CodeEventRecord : public Nan::ObjectWrap {
+ private:
+  int scriptId = 0;
+  uintptr_t address;
+  uintptr_t previousAddress;
+  size_t size;
+  int line;
+  int column;
+  std::string comment;
+  std::string functionName;
+  std::string scriptName;
+
+ public:
+  explicit CodeEventRecord(v8::Isolate* isolate,
+                           uintptr_t address,
+                           uintptr_t previousAddress,
+                           size_t size,
+                           int line,
+                           int column,
+                           std::string comment,
+                           v8::Local<v8::String> functionName,
+                           v8::Local<v8::String> scriptName);
+
+  explicit CodeEventRecord(v8::Isolate* isolate,
+                           uintptr_t address,
+                           uintptr_t previousAddress = 0,
+                           size_t size = 0,
+                           int line = 0,
+                           int column = 0,
+                           std::string comment = "",
+                           std::string functionName = "",
+                           std::string scriptName = "");
+
+  explicit CodeEventRecord(v8::Isolate* isolate, v8::CodeEvent* code_event);
+
+  void SetScriptId(int _id);
+
+  v8::Local<v8::Integer> GetScriptId(v8::Isolate *isolate);
+  v8::Local<v8::Integer> GetAddress(v8::Isolate* isolate);
+  v8::Local<v8::Integer> GetPreviousAddress(v8::Isolate* isolate);
+  v8::Local<v8::Integer> GetSize(v8::Isolate* isolate);
+  v8::Local<v8::Integer> GetLine(v8::Isolate* isolate);
+  v8::Local<v8::Integer> GetColumn(v8::Isolate* isolate);
+  v8::Local<v8::Value> GetFunctionName(v8::Isolate* isolate);
+  v8::Local<v8::Value> GetScriptName(v8::Isolate* isolate);
+  v8::Local<v8::Value> GetComment(v8::Isolate* isolate);
+
+  bool Equal(const CodeEventRecord *rhs) const;
+
+  friend class CodeMap;
+};
+
+}; // namespace dd

package/bindings/code-map.cc

@@ -0,0 +1,112 @@
+#include <unordered_map>
+
+#include <node.h>
+
+#include "profilers/cpu.hh"
+#include "code-map.hh"
+
+namespace dd {
+
+static std::unordered_map<v8::Isolate*, std::shared_ptr<CodeMap>> code_maps_;
+
+CodeMap::CodeMap(v8::Isolate* isolate, CodeEntries entries)
+  : CodeEventHandler(isolate),
+    code_entries_(entries),
+    isolate_(isolate) {}
+
+CodeMap::~CodeMap() {
+  Disable();
+}
+
+std::shared_ptr<CodeMap> CodeMap::For(v8::Isolate* isolate) {
+  auto maybe = code_maps_.find(isolate);
+  if (maybe != code_maps_.end()) {
+    return maybe->second;
+  }
+
+  code_maps_[isolate] = std::make_shared<CodeMap>(isolate);
+  return code_maps_[isolate];
+}
+
+CodeEntries CodeMap::Entries() {
+  return code_entries_;
+}
+
+void CodeMap::Enable() {
+  if (++refs == 1) {
+    CodeEventHandler::Enable();
+    isolate_->SetJitCodeEventHandler(v8::kJitCodeEventDefault,
+                                    StaticHandleJitEvent);
+  }
+}
+
+void CodeMap::Disable() {
+  if (--refs == 0) {
+    CodeEventHandler::Disable();
+    isolate_->SetJitCodeEventHandler(v8::kJitCodeEventDefault, nullptr);
+    code_entries_.clear();
+  }
+}
+
+// TODO: unsure of ordering but might need bi-directional merging for script id
+void CodeMap::HandleJitEvent(const v8::JitCodeEvent* event) {
+  if (event->type == v8::JitCodeEvent::CODE_REMOVED) {
+    Remove(reinterpret_cast<uintptr_t>(event->code_start));
+    return;
+  }
+
+  CodeEntries::iterator it = code_entries_.find(
+      reinterpret_cast<uintptr_t>(event->code_start));
+
+  if (it != code_entries_.end() && !event->script.IsEmpty()) {
+    it->second->SetScriptId(event->script->GetId());
+  }
+}
+
+void CodeMap::StaticHandleJitEvent(const v8::JitCodeEvent* event) {
+  auto code_map = CodeMap::For(event->isolate);
+  code_map->HandleJitEvent(event);
+}
+
+// TODO: Figure out if additional checks are needed to cleanup expired regions.
+// If size of previous is greater than offset of new position, the old record
+// must be invalid, clean it up.
+void CodeMap::Handle(v8::CodeEvent* code_event) {
+#if NODE_MODULE_VERSION > 79
+  if (code_event->GetCodeType() == v8::CodeEventType::kRelocationType) {
+    CodeEntries::iterator it = code_entries_.find(
+      code_event->GetPreviousCodeStartAddress());
+    if (it != code_entries_.end()) {
+      code_entries_.erase(it);
+    }
+  }
+#endif
+
+  Add(code_event->GetCodeStartAddress(), 
+      std::make_shared<CodeEventRecord>(isolate_, code_event));
+}
+
+void CodeMap::Add(uintptr_t address, std::shared_ptr<CodeEventRecord> record) {
+  code_entries_.insert(std::make_pair(address, std::move(record)));
+}
+
+void CodeMap::Remove(uintptr_t address) {
+  code_entries_.erase(address);
+}
+
+void CodeMap::Clear() {
+  code_entries_.clear();
+}
+
+std::shared_ptr<CodeEventRecord> CodeMap::Lookup(uintptr_t address) {
+  CodeEntries::iterator it = code_entries_.upper_bound(address);
+  if (it == code_entries_.begin()) return nullptr;
+  --it;
+  uintptr_t start_address = it->first;
+  std::shared_ptr<CodeEventRecord> entry = it->second;
+  uintptr_t code_end = start_address + entry->size;
+  if (address >= code_end) return nullptr;
+  return entry;
+}
+
+}; // namespace dd

package/bindings/code-map.hh

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <string>
+#include <map>
+
+#include <node_object_wrap.h> // cppcheck-suppress missingIncludeSystem
+#if NODE_MODULE_VERSION >= 102
+#include <v8-callbacks.h>
+#endif
+#include <v8-profiler.h>
+#include <v8.h>
+
+#include "code-event-record.hh"
+
+namespace dd {
+
+using CodeEntries = std::map<uintptr_t, std::shared_ptr<CodeEventRecord>>;
+
+class CodeMap : public v8::CodeEventHandler {
+ private:
+  CodeEntries code_entries_;
+  v8::Isolate* isolate_;
+  int refs = 0;
+
+  void HandleJitEvent(const v8::JitCodeEvent* event);
+  static void StaticHandleJitEvent(const v8::JitCodeEvent* event);
+
+ public:
+  explicit CodeMap(v8::Isolate* isolate, CodeEntries entries = {});
+  ~CodeMap();
+
+  static std::shared_ptr<CodeMap> For(v8::Isolate* isolate);
+
+  CodeEntries Entries();
+
+  void Enable();
+  void Disable();
+
+  void Add(uintptr_t address, std::shared_ptr<CodeEventRecord> record);
+  void Remove(uintptr_t address);
+  void Clear();
+
+  void Handle(v8::CodeEvent* code_event) override;
+  std::shared_ptr<CodeEventRecord> Lookup(uintptr_t address);
+};
+
+}; // namespace dd

package/bindings/cpu-time.cc

@@ -0,0 +1,89 @@
+#include "cpu-time.hh"
+
+#ifdef __linux__
+#include <errno.h>
+#include <pthread.h>
+#include <string.h>
+#elif __APPLE__
+#define _DARWIN_C_SOURCE
+#include <mach/mach_error.h>
+#include <mach/mach_init.h>
+#include <mach/thread_act.h>
+#elif _WIN32
+#include <Windows.h>
+#endif
+
+namespace dd {
+
+CpuTime::CpuTime(struct timespec time) : last_(time) {
+#ifdef __linux__
+  pthread_getcpuclockid(pthread_self(), &clockid);
+#elif __APPLE__
+  thread_ = mach_thread_self();
+#elif _WIN32
+  thread_ = GetCurrentThread();
+#endif
+}
+
+CpuTime::CpuTime()
+  : CpuTime(Now()) {}
+
+int64_t CpuTime::Diff(struct timespec now) {
+  int64_t current = now.tv_sec * INT64_C(1000000000) + now.tv_nsec;
+  int64_t prev = last_.tv_sec * INT64_C(1000000000) + last_.tv_nsec;
+  int64_t cpu_time = current - prev;
+
+  last_ = now;
+
+  return cpu_time;
+}
+
+int64_t CpuTime::Diff() {
+  return Diff(Now());
+}
+
+struct timespec CpuTime::Now() {
+  struct timespec cpu_time = {0, 0};
+
+#ifdef __linux__
+  if (clock_gettime(clockid, &cpu_time)) {
+    return (struct timespec){0, 0};
+  }
+#elif __APPLE__
+  mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+  thread_basic_info_data_t info;
+  kern_return_t kr =
+    thread_info(thread_, THREAD_BASIC_INFO, (thread_info_t)&info, &count);
+
+  if (kr != KERN_SUCCESS) {
+    return cpu_time;
+  }
+
+  cpu_time = {
+    // tv_sec
+    info.user_time.seconds + info.system_time.seconds,
+    // tv_nsec
+    (info.user_time.microseconds + info.system_time.microseconds) * 1000,
+  };
+#elif _WIN32
+  FILETIME a, b, c, d;
+  if (!GetThreadTimes(thread_, &a, &b, &c, &d)) {
+    return cpu_time;
+  }
+
+  // Convert 100-ns interval to nanooseconds
+  uint64_t us = (((uint64_t)d.dwHighDateTime << 32) |
+                (uint64_t)d.dwLowDateTime) * 100;
+
+  cpu_time = {
+    // tv_sec
+    (time_t)(us / 1000000000),
+    // tv_nsec
+    (long)(us % 1000000000),
+  };
+#endif
+
+  return cpu_time;
+}
+
+}

package/bindings/cpu-time.hh

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include <time.h>
+
+#ifdef __linux__
+#include <pthread.h>
+#elif __APPLE__
+#include <mach/mach.h>
+#elif _WIN32
+#include <Windows.h>
+#endif
+
+namespace dd {
+
+class CpuTime {
+ private:
+  struct timespec last_;
+#ifdef __linux__
+  clockid_t clockid;
+#elif __APPLE__
+  mach_port_t thread_;
+#elif _WIN32
+  HANDLE thread_;
+#endif
+
+ public:
+  CpuTime(struct timespec time);
+  CpuTime();
+  int64_t Diff(struct timespec time);
+  int64_t Diff();
+  struct timespec Now();
+};
+
+} // namespace dd