nsolid.h

Go to the documentation of this file.

#ifndef SRC_NSOLID_H_
#define SRC_NSOLID_H_
 
#include "node.h"
#include "uv.h"
 
#include <memory>
#include <string>
 
namespace node {
namespace nsolid {
 
#define NSOLID_PROCESS_METRICS_STRINGS(V)                                      \
  V(std::string, title, title, EOther)                                         \
  V(std::string, user, user, EOther)
 
#define NSOLID_PROCESS_METRICS_NUMBERS(V)                                      \
  V(uint64_t, timestamp, timestamp, ECounter)                                  \
  V(uint64_t, uptime, uptime, ECounter)                                        \
  V(uint64_t, system_uptime, systemUptime, ECounter)                           \
  V(uint64_t, free_mem, freeMem, EGauge)                                       \
  V(uint64_t, block_input_op_count, blockInputOpCount, ECounter)               \
  V(uint64_t, block_output_op_count, blockOutputOpCount, ECounter)             \
  V(uint64_t, ctx_switch_involuntary_count,                                    \
              ctxSwitchInvoluntaryCount,                                       \
              ECounter)                                                        \
  V(uint64_t, ctx_switch_voluntary_count, ctxSwitchVoluntaryCount, ECounter)   \
  V(uint64_t, ipc_received_count, ipcReceivedCount, ECounter)                  \
  V(uint64_t, ipc_sent_count, ipcSentCount, ECounter)                          \
  V(uint64_t, page_fault_hard_count, pageFaultHardCount, ECounter)             \
  V(uint64_t, page_fault_soft_count, pageFaultSoftCount, ECounter)             \
  V(uint64_t, signal_count, signalCount, ECounter)                             \
  V(uint64_t, swap_count, swapCount, ECounter)                                 \
  V(uint64_t, rss, rss, EGauge)                                                \
  V(double, load_1m, load1m, EGauge)                                           \
  V(double, load_5m, load5m, EGauge)                                           \
  V(double, load_15m, load15m, EGauge)                                         \
  V(double, cpu_user_percent, cpuUserPercent, EGauge)                          \
  V(double, cpu_system_percent, cpuSystemPercent, EGauge)                      \
  V(double, cpu_percent, cpuPercent, EGauge)
 
#define NSOLID_PROCESS_METRICS(V)                                              \
  NSOLID_PROCESS_METRICS_STRINGS(V)                                            \
  NSOLID_PROCESS_METRICS_NUMBERS(V)
 
#define NSOLID_ENV_METRICS(V)                                                  \
  V(uint64_t, thread_id, threadId, EOther)                                     \
  V(uint64_t, timestamp, timestamp, ECounter)                                  \
  V(uint64_t, active_handles, activeHandles, EGauge)                           \
  V(uint64_t, active_requests, activeRequests, EGauge)                         \
  V(uint64_t, total_heap_size, heapTotal, EGauge)                              \
  V(uint64_t, total_heap_size_executable, totalHeapSizeExecutable, EGauge)     \
  V(uint64_t, total_physical_size, totalPhysicalSize, EGauge)                  \
  V(uint64_t, total_available_size, totalAvailableSize, EGauge)                \
  V(uint64_t, used_heap_size, heapUsed, EGauge)                                \
  V(uint64_t, heap_size_limit, heapSizeLimit, EGauge)                          \
  V(uint64_t, malloced_memory, mallocedMemory, EGauge)                         \
  V(uint64_t, external_memory, externalMem, EGauge)                            \
  V(uint64_t, peak_malloced_memory, peakMallocedMemory, EGauge)                \
  V(uint64_t, number_of_native_contexts, numberOfNativeContexts, EGauge)       \
  V(uint64_t, number_of_detached_contexts, numberOfDetachedContexts, EGauge)   \
  V(uint64_t, gc_count, gcCount, ECounter)                                     \
  V(uint64_t, gc_forced_count, gcForcedCount, ECounter)                        \
  V(uint64_t, gc_full_count, gcFullCount, ECounter)                            \
  V(uint64_t, gc_major_count, gcMajorCount, ECounter)                          \
  V(double, gc_dur_us99_ptile, gcDurUs99Ptile, ESeries)                        \
  V(double, gc_dur_us_median, gcDurUsMedian, ESeries)                          \
  V(uint64_t, dns_count, dnsCount, ECounter)                                   \
  V(uint64_t, http_client_abort_count, httpClientAbortCount, ECounter)         \
  V(uint64_t, http_client_count, httpClientCount, ECounter)                    \
  V(uint64_t, http_server_abort_count, httpServerAbortCount, ECounter)         \
  V(uint64_t, http_server_count, httpServerCount, ECounter)                    \
  V(double, dns99_ptile, dns99Ptile, ESeries)                                  \
  V(double, dns_median, dnsMedian, ESeries)                                    \
  V(double, http_client99_ptile, httpClient99Ptile, ESeries)                   \
  V(double, http_client_median, httpClientMedian, ESeries)                     \
  V(double, http_server99_ptile, httpServer99Ptile, ESeries)                   \
  V(double, http_server_median, httpServerMedian, ESeries)                     \
  V(uint64_t, loop_idle_time, loopIdleTime, EGauge)                            \
  V(uint64_t, loop_iterations, loopIterations, ECounter)                       \
  V(uint64_t, loop_iter_with_events, loopIterWithEvents, ECounter)             \
  V(uint64_t, events_processed, eventsProcessed, ECounter)                     \
  V(uint64_t, events_waiting, eventsWaiting, EGauge)                           \
  V(uint64_t, provider_delay, providerDelay, EGauge)                           \
  V(uint64_t, processing_delay, processingDelay, EGauge)                       \
  V(double, loop_utilization, loopUtilization, EGauge)                         \
  V(double, res_5s, res5s, EGauge)                                             \
  V(double, res_1m, res1m, EGauge)                                             \
  V(double, res_5m, res5m, EGauge)                                             \
  V(double, res_15m, res15m, EGauge)                                           \
  V(uint64_t, loop_total_count, loopTotalCount, ECounter)                      \
  V(double, loop_avg_tasks, loopAvgTasks, EGauge)                              \
  V(double, loop_estimated_lag, loopEstimatedLag, EGauge)                      \
  V(double, loop_idle_percent, loopIdlePercent, EGauge)
 
#define NSOLID_ERRORS(V)                                                       \
  V(SUCCESS, 0, "Success")                                                     \
  V(NOT_LICENSED, 1, "N|Solid Runtime is not Licensed")
 
enum NSolidErr {
#define V(Type, Value, Msg)                                                    \
  NSOLID_E_##Type = Value,
  NSOLID_ERRORS(V)
#undef V
#define X(Type, Msg)                                                           \
  NSOLID_E_UV_ ## Type = UV_ ## Type,
  UV_ERRNO_MAP(X)
#undef X
};
 
 
class ProcessMetrics;
class ThreadMetrics;
 
namespace internal {
 
using on_block_loop_hook_proxy_sig = void(*)(uint64_t, std::string, void*);
using on_unblock_loop_hook_proxy_sig = on_block_loop_hook_proxy_sig;
using thread_added_hook_proxy_sig = void(*)(uint64_t, void*);
using thread_removed_hook_proxy_sig = thread_added_hook_proxy_sig;
using on_license_proxy_sig = void(*)(bool, uint64_t, void*);
using deleter_sig = void(*)(void*);
 
template <typename G>
void on_block_loop_hook_proxy_(uint64_t, std::string, void*);
template <typename G>
void on_unblock_loop_hook_proxy_(uint64_t, std::string, void*);
template <typename G>
void thread_added_hook_proxy_(uint64_t thread_id, void* data);
template <typename G>
void thread_removed_hook_proxy_(uint64_t thread_id, void* data);
template <typename G>
void license_hook_proxy_(bool licensed, uint64_t expiration, void* g);
template <typename G>
void delete_proxy_(void* g);
 
 
int on_block_loop_hook_(uint64_t,
                        void*,
                        on_block_loop_hook_proxy_sig,
                        deleter_sig);
int on_unblock_loop_hook_(void*, on_unblock_loop_hook_proxy_sig, deleter_sig);
int thread_added_hook_(void*, thread_added_hook_proxy_sig, deleter_sig);
int thread_removed_hook_(void*,
                         thread_removed_hook_proxy_sig,
                         deleter_sig);
void SetOnLicenseHook(on_license_proxy_sig, void*, deleter_sig);
 
}  // namespace internal
 
enum class NODE_EXTERN MetricsType: unsigned int {
  ECounter, 
  EGauge, 
  ESeries,
  EOther
};
 
 
class NODE_EXTERN ProcessMetrics {
 public:
  ProcessMetrics();
  ~ProcessMetrics() = default;
 
  struct MetricsStor {
#define PM1(Type, CName, JSName, MType) Type CName;
    NSOLID_PROCESS_METRICS_STRINGS(PM1)
#undef PM1
#define PM2(Type, CName, JSName, MType) Type CName = 0;
    NSOLID_PROCESS_METRICS_NUMBERS(PM2)
#undef PM2
    // This is a duplicate of cpuPercent, for backwards compatibility.
    double cpu = 0;
  };
 
  std::string toJSON();
  int Get(MetricsStor* stor);
  int Update();
 
 private:
  MetricsStor stor_;
  uint64_t cpu_prev_[3];
  uint64_t cpu_prev_time_;
};
 
 
class NODE_EXTERN ThreadMetrics {
 public:
  struct MetricsStor;
  using thread_metrics_proxy_sig = void(*)(ThreadMetrics*);
 
  struct MetricsStor {
#define EM(Type, CName, JSName, MType) Type CName = 0;
    NSOLID_ENV_METRICS(EM)
#undef EM
  };
 
  explicit ThreadMetrics(uint64_t thread_id);
  ThreadMetrics() = delete;
  ~ThreadMetrics();
 
  // All these calls are thread-safe.
  std::string toJSON();
  int Get(MetricsStor* stor);
  // The callback is called from the NSolid thread.
  // signature: cb(ThreadMetrics*, ...Data)
  template <typename Cb, typename... Data>
  int Update(Cb&& cb, Data&&... data);
 
 private:
  int get_thread_metrics_();
  static void get_general_metrics_(void* inst, ThreadMetrics* tm);
  static void get_heap_stats_(void* inst, ThreadMetrics* tm);
  static void get_event_loop_stats_(void* inst, ThreadMetrics* tm);
  static void get_http_dns_stats_(void* inst, ThreadMetrics* tm);
  static void get_gc_stats_(void* inst, ThreadMetrics* tm);
 
  template <typename G>
  static void thread_metrics_proxy_(ThreadMetrics* tm);
 
  uint64_t thread_id_ = 0xFFFFFFFFFFFFFFFF;
  uint64_t prev_idle_time_ = 0;
  uint64_t prev_call_time_;
  uint64_t current_hrtime_;
  void* user_data_ = nullptr;
  thread_metrics_proxy_sig proxy_;
 
  uv_mutex_t stor_lock_;
  MetricsStor stor_;
};
 
 
class NODE_EXTERN MetricsStream {
 public:
  enum class Type: uint32_t {
    kRawDns = 1 << 0, 
    kRawHttpClient = 1 << 1, 
    kRawHttpServer = 1 << 2, 
    kRawGcRegular = 1 << 3, 
    kRawGcForced = 1 << 4, 
    kRawGcFull = 1 << 5, 
    kRawGcMajor = 1 << 6, 
    kRawGc = 120 
  };
 
  using metrics_stream_bucket = std::vector<std::tuple<Type, double>>;
  using metrics_stream_proxy_sig = void(*)(MetricsStream*,
                                           metrics_stream_bucket,
                                           void*);
 
  explicit MetricsStream(uint64_t thread_id);
  MetricsStream() = delete;
  ~MetricsStream();
 
  // The callback is called from the NSolid thread.
  // signature: cb(MetricsStream*, metrics_stream_bucket, ...Data)
  template <typename Cb, typename... Data>
  int Start(uint32_t flags,
            uint64_t timeout,
            uint32_t max_items,
            Cb&& cb,
            Data&&... data);
  int Stop();
  uint64_t ThreadId();
 
 private:
  template <typename G>
  static void metrics_stream_proxy_(MetricsStream*,
                                    metrics_stream_bucket,
                                    void*);
  template <typename G>
  static void deleter_(void*);
 
  int DoStart(uint32_t flags,
              uint64_t timeout,
              uint32_t max_items,
              metrics_stream_proxy_sig,
              void(*)(void*),
              void* cb);
 
  class Impl;
  std::unique_ptr<Impl> impl_;
};
 
 
class NODE_EXTERN CpuProfiler {
 public:
  using cpu_profiler_proxy_sig = void(*)(int, std::string, void*);
 
  template <typename Cb, typename... Data>
  static int TakeProfile(uint64_t thread_id,
                         uint64_t duration,
                         Cb&& cb,
                         Data&&... data);
  static int StopProfile(uint64_t thread_id);
 
 private:
  static int get_cpu_profile_(uint64_t thread_id,
                              uint64_t duration,
                              cpu_profiler_proxy_sig proxy,
                              void* data);
  template <typename G>
  static void cpu_profiler_proxy_(int status, std::string json, void* data);
};
 
 
class NODE_EXTERN Snapshot {
 public:
  using snapshot_proxy_sig = void(*)(int, std::string, void*);
 
  template <typename Cb, typename... Data>
  int TakeSnapshot(uint64_t thread_id, Cb&& cb, Data&&... data);
 
 private:
  int get_snapshot_(uint64_t thread_id,
                    snapshot_proxy_sig proxy,
                    void* data);
  template <typename G>
  static void snapshot_proxy_(int status, std::string profile, void* data);
};
 
 
NODE_EXTERN int ModuleInfo(uint64_t thread_id, std::string* json);
NODE_EXTERN int ProcessInfo(std::string* json);
 
 
template <typename Cb, typename... Data>
NODE_EXTERN int OnBlockedLoopHook(uint64_t threshold, Cb&& cb, Data&&... data);
template <typename Cb, typename... Data>
NODE_EXTERN int OnUnblockedLoopHook(Cb&& cb, Data&&... data);
 
 
template <typename Cb, typename... Data>
NODE_EXTERN int ThreadAddedHook(Cb&& cb, Data&&... data);
template <typename Cb, typename... Data>
NODE_EXTERN int ThreadRemovedHook(Cb&& cb, Data&&... data);
 
 
template <typename Cb, typename... Data>
NODE_EXTERN int OnLicenseHook(Cb&& cb, Data&&... data);
NODE_EXTERN void License(std::string token);
NODE_EXTERN bool IsLicensed();
NODE_EXTERN uint64_t LicenseExpiration();
 
NODE_EXTERN uint64_t ThreadId(v8::Local<v8::Context> context);
 
 
 
// DEFINITIONS //
template <typename Cb, typename... Data>
int ThreadMetrics::Update(Cb&& cb, Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, std::forward<Data>(data)...));
 
  // _1 - ThreadMetrics*
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, std::forward<Data>(data)...));
 
  user_data_ = static_cast<void*>(user_data.get());
  proxy_ = thread_metrics_proxy_<UserData>;
  stor_.thread_id = thread_id_;
 
  int er = get_thread_metrics_();
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename G>
void ThreadMetrics::thread_metrics_proxy_(ThreadMetrics* tm) {
  G* g = static_cast<G*>(tm->user_data_);
  tm->user_data_ = nullptr;
  tm->proxy_ = nullptr;
  (*g)(tm);
  delete g;
}
 
 
template <typename Cb, typename... Data>
int MetricsStream::Start(uint32_t flags,
                         uint64_t timeout,
                         uint32_t max_items,
                         Cb&& cb,
                         Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
  // _1 - MetricsStream* metrics_stream
  // _2 - metrics_stream_bucket bucket
  UserData* user_data = new UserData(std::bind(
    std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
  int err = DoStart(flags,
                    timeout,
                    max_items,
                    metrics_stream_proxy_<UserData>,
                    internal::delete_proxy_<UserData>,
                    static_cast<void*>(user_data));
  if (err) {
    delete user_data;
  }
 
  return err;
}
 
 
template <typename G>
void MetricsStream::metrics_stream_proxy_(
    MetricsStream* ms, metrics_stream_bucket bucket, void* g) {
  (*static_cast<G*>(g))(ms, bucket);
}
 
 
template <typename Cb, typename... Data>
int CpuProfiler::TakeProfile(uint64_t thread_id,
                             uint64_t duration,
                             Cb&& cb,
                             Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  // _1 - int status
  // _2 - std::string json
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  int er = get_cpu_profile_(thread_id,
                            duration,
                            cpu_profiler_proxy_<UserData>,
                            user_data.get());
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename G>
void CpuProfiler::cpu_profiler_proxy_(int status,
                                      std::string json,
                                      void* data) {
  (*static_cast<G*>(data))(status, json);
  delete static_cast<G*>(data);
}
 
 
template <typename Cb, typename... Data>
int Snapshot::TakeSnapshot(uint64_t thread_id,
                           Cb&& cb,
                           Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  // _1 - int status
  // _2 - std::string json
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  int er = get_snapshot_(thread_id,
                         snapshot_proxy_<UserData>,
                         user_data.get());
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename G>
void Snapshot::snapshot_proxy_(int status, std::string profile, void* data) {
  (*static_cast<G*>(data))(status, profile);
  delete static_cast<G*>(data);
}
 
 
template <typename Cb, typename... Data>
int OnBlockedLoopHook(uint64_t threshold, Cb&& cb, Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  // _1 - uint64_t thread_id
  // _2 - std::string info
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  int er = internal::on_block_loop_hook_(
      threshold,
      user_data.get(),
      internal::on_block_loop_hook_proxy_<UserData>,
      internal::delete_proxy_<UserData>);
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename Cb, typename... Data>
int OnUnblockedLoopHook(Cb&& cb, Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  // _1 - uint64_t thread_id
  // _2 - std::string info
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  int er = internal::on_unblock_loop_hook_(
    user_data.get(),
    internal::on_unblock_loop_hook_proxy_<UserData>,
    internal::delete_proxy_<UserData>);
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename Cb, typename... Data>
int ThreadAddedHook(Cb&& cb, Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, std::forward<Data>(data)...));
 
  if (!IsLicensed())
    return NSOLID_E_NOT_LICENSED;
 
  // _1 - uint64_t thread_id
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, std::forward<Data>(data)...));
 
  int er = internal::thread_added_hook_(
      user_data.get(),
      internal::thread_added_hook_proxy_<UserData>,
      internal::delete_proxy_<UserData>);
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename Cb, typename... Data>
int ThreadRemovedHook(Cb&& cb, Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, std::forward<Data>(data)...));
 
  if (!IsLicensed())
    return NSOLID_E_NOT_LICENSED;
 
  // _1 - uint64_t thread_id
  std::unique_ptr<UserData> user_data = std::make_unique<UserData>(std::bind(
        std::forward<Cb>(cb), _1, std::forward<Data>(data)...));
 
  int er = internal::thread_removed_hook_(
      user_data.get(),
      internal::thread_removed_hook_proxy_<UserData>,
      internal::delete_proxy_<UserData>);
  if (!er)
    user_data.release();
  return er;
}
 
 
template <typename Cb, typename... Data>
int OnLicenseHook(Cb&& cb, Data&&... data) {
  // NOLINTNEXTLINE(build/namespaces)
  using namespace std::placeholders;
  using UserData = decltype(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  // _1 - bool licensed
  // _2 - uint64_t expiration
  UserData* user_data = new UserData(std::bind(
        std::forward<Cb>(cb), _1, _2, std::forward<Data>(data)...));
 
  internal::SetOnLicenseHook(internal::license_hook_proxy_<UserData>,
                             user_data,
                             internal::delete_proxy_<UserData>);
  return 0;
}
 
 
namespace internal {
 
template <typename G>
void on_block_loop_hook_proxy_(uint64_t thread_id,
                               std::string info,
                               void* data) {
  (*static_cast<G*>(data))(thread_id, info);
}
 
template <typename G>
void on_unblock_loop_hook_proxy_(uint64_t thread_id,
                                 std::string info,
                                 void* data) {
  (*static_cast<G*>(data))(thread_id, info);
}
 
template <typename G>
void thread_added_hook_proxy_(uint64_t thread_id, void* data) {
  (*static_cast<G*>(data))(thread_id);
}
 
template <typename G>
void thread_removed_hook_proxy_(uint64_t thread_id, void* data) {
  (*static_cast<G*>(data))(thread_id);
}
 
template <typename G>
void license_hook_proxy_(bool licensed, uint64_t expiration, void* g) {
  (*static_cast<G*>(g))(licensed, expiration);
}
 
template <typename G>
void delete_proxy_(void* g) {
  delete static_cast<G*>(g);
}
 
}  // namespace internal
}  // namespace nsolid
}  // namespace node
 
#endif  // SRC_NSOLID_H_