@encharm/cws 4.1.0 → 4.2.0

package/src/headers/18/node_sockaddr.h

@@ -0,0 +1,405 @@
+#ifndef SRC_NODE_SOCKADDR_H_
+#define SRC_NODE_SOCKADDR_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "env.h"
+#include "memory_tracker.h"
+#include "base_object.h"
+#include "node.h"
+#include "node_worker.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <memory>
+#include <string>
+#include <list>
+#include <unordered_map>
+
+namespace node {
+
+class Environment;
+
+class SocketAddress : public MemoryRetainer {
+ public:
+  enum class CompareResult {
+    NOT_COMPARABLE = -2,
+    LESS_THAN,
+    SAME,
+    GREATER_THAN
+  };
+
+  struct Hash {
+    size_t operator()(const SocketAddress& addr) const;
+  };
+
+  inline bool operator==(const SocketAddress& other) const;
+  inline bool operator!=(const SocketAddress& other) const;
+
+  inline bool operator<(const SocketAddress& other) const;
+  inline bool operator>(const SocketAddress& other) const;
+  inline bool operator<=(const SocketAddress& other) const;
+  inline bool operator>=(const SocketAddress& other) const;
+
+  inline static bool is_numeric_host(const char* hostname);
+  inline static bool is_numeric_host(const char* hostname, int family);
+
+  // Returns true if converting {family, host, port} to *addr succeeded.
+  static bool ToSockAddr(
+      int32_t family,
+      const char* host,
+      uint32_t port,
+      sockaddr_storage* addr);
+
+  // Returns true if converting {family, host, port} to *addr succeeded.
+  static bool New(
+      int32_t family,
+      const char* host,
+      uint32_t port,
+      SocketAddress* addr);
+
+  static bool New(
+      const char* host,
+      uint32_t port,
+      SocketAddress* addr);
+
+  // Returns the port for an IPv4 or IPv6 address.
+  inline static int GetPort(const sockaddr* addr);
+  inline static int GetPort(const sockaddr_storage* addr);
+
+  // Returns the numeric host as a string for an IPv4 or IPv6 address.
+  inline static std::string GetAddress(const sockaddr* addr);
+  inline static std::string GetAddress(const sockaddr_storage* addr);
+
+  // Returns the struct length for an IPv4, IPv6 or UNIX domain.
+  inline static size_t GetLength(const sockaddr* addr);
+  inline static size_t GetLength(const sockaddr_storage* addr);
+
+  SocketAddress() = default;
+
+  inline explicit SocketAddress(const sockaddr* addr);
+  inline SocketAddress(const SocketAddress& addr);
+  inline SocketAddress& operator=(const sockaddr* other);
+  inline SocketAddress& operator=(const SocketAddress& other);
+
+  inline const sockaddr& operator*() const;
+  inline const sockaddr* operator->() const;
+
+  inline const sockaddr* data() const;
+  inline const uint8_t* raw() const;
+  inline sockaddr* storage();
+  inline size_t length() const;
+
+  inline int family() const;
+  inline std::string address() const;
+  inline int port() const;
+
+  // Returns true if the given other SocketAddress is a match
+  // for this one. The addresses are a match if:
+  // 1. They are the same family and match identically
+  // 2. They are different family but match semantically (
+  //     for instance, an IPv4 address in IPv6 notation)
+  bool is_match(const SocketAddress& other) const;
+
+  // Compares this SocketAddress to the given other SocketAddress.
+  CompareResult compare(const SocketAddress& other) const;
+
+  // Returns true if this SocketAddress is within the subnet
+  // identified by the given network address and CIDR prefix.
+  bool is_in_network(const SocketAddress& network, int prefix) const;
+
+  // If the SocketAddress is an IPv6 address, returns the
+  // current value of the IPv6 flow label, if set. Otherwise
+  // returns 0.
+  inline uint32_t flow_label() const;
+
+  // If the SocketAddress is an IPv6 address, sets the
+  // current value of the IPv6 flow label. If not an
+  // IPv6 address, set_flow_label is a non-op. It
+  // is important to note that the flow label,
+  // while represented as an uint32_t, the flow
+  // label is strictly limited to 20 bits, and
+  // this will assert if any value larger than
+  // 20-bits is specified.
+  inline void set_flow_label(uint32_t label = 0);
+
+  inline void Update(uint8_t* data, size_t len);
+  inline void Update(const sockaddr* data, size_t len);
+
+  static SocketAddress FromSockName(const uv_udp_t& handle);
+  static SocketAddress FromSockName(const uv_tcp_t& handle);
+  static SocketAddress FromPeerName(const uv_udp_t& handle);
+  static SocketAddress FromPeerName(const uv_tcp_t& handle);
+
+  inline v8::MaybeLocal<v8::Object> ToJS(
+      Environment* env,
+      v8::Local<v8::Object> obj = v8::Local<v8::Object>()) const;
+
+  inline std::string ToString() const;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(SocketAddress)
+  SET_SELF_SIZE(SocketAddress)
+
+  template <typename T>
+  using Map = std::unordered_map<SocketAddress, T, Hash>;
+
+ private:
+  sockaddr_storage address_;
+};
+
+class SocketAddressBase : public BaseObject {
+ public:
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static BaseObjectPtr<SocketAddressBase> Create(
+      Environment* env,
+      std::shared_ptr<SocketAddress> address);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Detail(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LegacyDetail(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetFlowLabel(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SocketAddressBase(
+    Environment* env,
+    v8::Local<v8::Object> wrap,
+    std::shared_ptr<SocketAddress> address);
+
+  inline const std::shared_ptr<SocketAddress>& address() const {
+    return address_;
+  }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressBase)
+  SET_SELF_SIZE(SocketAddressBase)
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class TransferData : public worker::TransferData {
+   public:
+    inline explicit TransferData(const SocketAddressBase* wrap)
+        : address_(wrap->address_) {}
+
+    inline explicit TransferData(std::shared_ptr<SocketAddress> address)
+        : address_(std::move(address)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressBase::TransferData)
+    SET_SELF_SIZE(TransferData)
+
+   private:
+    std::shared_ptr<SocketAddress> address_;
+  };
+
+ private:
+  std::shared_ptr<SocketAddress> address_;
+};
+
+template <typename T>
+class SocketAddressLRU : public MemoryRetainer {
+ public:
+  using Type = typename T::Type;
+
+  inline explicit SocketAddressLRU(size_t max_size);
+
+  // If the item already exists, returns a reference to
+  // the existing item, adjusting items position in the
+  // LRU. If the item does not exist, emplaces the item
+  // and returns the new item.
+  Type* Upsert(const SocketAddress& address);
+
+  // Returns a reference to the item if it exists, or
+  // nullptr. The position in the LRU is not modified.
+  Type* Peek(const SocketAddress& address) const;
+
+  size_t size() const { return map_.size(); }
+  size_t max_size() const { return max_size_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressLRU)
+  SET_SELF_SIZE(SocketAddressLRU)
+
+ private:
+  using Pair = std::pair<SocketAddress, Type>;
+  using Iterator = typename std::list<Pair>::iterator;
+
+  void CheckExpired();
+
+  std::list<Pair> list_;
+  SocketAddress::Map<Iterator> map_;
+  size_t max_size_;
+};
+
+// A BlockList is used to evaluate whether a given
+// SocketAddress should be accepted for inbound or
+// outbound network activity.
+class SocketAddressBlockList : public MemoryRetainer {
+ public:
+  explicit SocketAddressBlockList(
+      std::shared_ptr<SocketAddressBlockList> parent = {});
+  ~SocketAddressBlockList() = default;
+
+  void AddSocketAddress(const std::shared_ptr<SocketAddress>& address);
+
+  void RemoveSocketAddress(const std::shared_ptr<SocketAddress>& address);
+
+  void AddSocketAddressRange(
+      const std::shared_ptr<SocketAddress>& start,
+      const std::shared_ptr<SocketAddress>& end);
+
+  void AddSocketAddressMask(
+      const std::shared_ptr<SocketAddress>& address,
+      int prefix);
+
+  bool Apply(const std::shared_ptr<SocketAddress>& address);
+
+  size_t size() const { return rules_.size(); }
+
+  v8::MaybeLocal<v8::Array> ListRules(Environment* env);
+
+  struct Rule : public MemoryRetainer {
+    virtual bool Apply(const std::shared_ptr<SocketAddress>& address) = 0;
+    inline v8::MaybeLocal<v8::Value> ToV8String(Environment* env);
+    virtual std::string ToString() = 0;
+  };
+
+  struct SocketAddressRule final : Rule {
+    std::shared_ptr<SocketAddress> address;
+
+    explicit SocketAddressRule(const std::shared_ptr<SocketAddress>& address);
+
+    bool Apply(const std::shared_ptr<SocketAddress>& address) override;
+    std::string ToString() override;
+
+    void MemoryInfo(node::MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressRule)
+    SET_SELF_SIZE(SocketAddressRule)
+  };
+
+  struct SocketAddressRangeRule final : Rule {
+    std::shared_ptr<SocketAddress> start;
+    std::shared_ptr<SocketAddress> end;
+
+    SocketAddressRangeRule(
+        const std::shared_ptr<SocketAddress>& start,
+        const std::shared_ptr<SocketAddress>& end);
+
+    bool Apply(const std::shared_ptr<SocketAddress>& address) override;
+    std::string ToString() override;
+
+    void MemoryInfo(node::MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressRangeRule)
+    SET_SELF_SIZE(SocketAddressRangeRule)
+  };
+
+  struct SocketAddressMaskRule final : Rule {
+    std::shared_ptr<SocketAddress> network;
+    int prefix;
+
+    SocketAddressMaskRule(
+        const std::shared_ptr<SocketAddress>& address,
+        int prefix);
+
+    bool Apply(const std::shared_ptr<SocketAddress>& address) override;
+    std::string ToString() override;
+
+    void MemoryInfo(node::MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressMaskRule)
+    SET_SELF_SIZE(SocketAddressMaskRule)
+  };
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressBlockList)
+  SET_SELF_SIZE(SocketAddressBlockList)
+
+ private:
+  bool ListRules(
+      Environment* env,
+      std::vector<v8::Local<v8::Value>>* vec);
+
+  std::shared_ptr<SocketAddressBlockList> parent_;
+  std::list<std::unique_ptr<Rule>> rules_;
+  SocketAddress::Map<std::list<std::unique_ptr<Rule>>::iterator> address_rules_;
+
+  Mutex mutex_;
+};
+
+class SocketAddressBlockListWrap : public BaseObject {
+ public:
+  static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context,
+                         void* priv);
+
+  static BaseObjectPtr<SocketAddressBlockListWrap> New(Environment* env);
+  static BaseObjectPtr<SocketAddressBlockListWrap> New(
+      Environment* env,
+      std::shared_ptr<SocketAddressBlockList> blocklist);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddAddress(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddRange(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AddSubnet(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Check(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetRules(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SocketAddressBlockListWrap(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      std::shared_ptr<SocketAddressBlockList> blocklist =
+          std::make_shared<SocketAddressBlockList>());
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(SocketAddressBlockListWrap)
+  SET_SELF_SIZE(SocketAddressBlockListWrap)
+
+  TransferMode GetTransferMode() const override {
+    return TransferMode::kCloneable;
+  }
+  std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
+
+  class TransferData : public worker::TransferData {
+   public:
+    inline explicit TransferData(const SocketAddressBlockListWrap* wrap)
+        : blocklist_(wrap->blocklist_) {}
+
+    inline explicit TransferData(
+        std::shared_ptr<SocketAddressBlockList> blocklist)
+        : blocklist_(std::move(blocklist)) {}
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    void MemoryInfo(MemoryTracker* tracker) const override;
+    SET_MEMORY_INFO_NAME(SocketAddressBlockListWrap::TransferData)
+    SET_SELF_SIZE(TransferData)
+
+   private:
+    std::shared_ptr<SocketAddressBlockList> blocklist_;
+  };
+
+ private:
+  std::shared_ptr<SocketAddressBlockList> blocklist_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_SOCKADDR_H_

package/src/headers/{12 → 18}/node_stat_watcher.h

@@ -30,15 +30,20 @@
 #include "v8.h"
 
 namespace node {
+namespace fs {
+class BindingData;
+}
 
 class Environment;
+class ExternalReferenceRegistry;
 
 class StatWatcher : public HandleWrap {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
  protected:
-  StatWatcher(Environment* env,
+  StatWatcher(fs::BindingData* binding_data,
               v8::Local<v8::Object> wrap,
               bool use_bigint);
 
@@ -57,6 +62,7 @@ class StatWatcher : public HandleWrap {
 
   uv_fs_poll_t watcher_;
   const bool use_bigint_;
+  BaseObjectPtr<fs::BindingData> binding_data_;
 };
 
 }  // namespace node

package/src/headers/{13 → 18}/node_url.h

@@ -71,8 +71,19 @@ struct url_data {
   std::string query;
   std::string fragment;
   std::vector<std::string> path;
+  std::string href;
 };
 
+namespace table_data {
+extern const char hex[1024];
+extern const uint8_t C0_CONTROL_ENCODE_SET[32];
+extern const uint8_t FRAGMENT_ENCODE_SET[32];
+extern const uint8_t PATH_ENCODE_SET[32];
+extern const uint8_t USERINFO_ENCODE_SET[32];
+extern const uint8_t QUERY_ENCODE_SET_NONSPECIAL[32];
+extern const uint8_t QUERY_ENCODE_SET_SPECIAL[32];
+}
+
 class URL {
  public:
   static void Parse(const char* input,
@@ -83,6 +94,8 @@ class URL {
                     const struct url_data* base,
                     bool has_base);
 
+  static std::string SerializeURL(const url_data& url, bool exclude);
+
   URL(const char* input, const size_t len) {
     Parse(input, len, kUnknownState, &context_, false, nullptr, false);
   }
@@ -160,6 +173,10 @@ class URL {
     return ret;
   }
 
+  std::string href() const {
+    return SerializeURL(context_, false);
+  }
+
   // Get the path of the file: URL in a format consumable by native file system
   // APIs. Returns an empty string if something went wrong.
   std::string ToFilePath() const;
@@ -176,7 +193,7 @@ class URL {
   URL() : URL("") {}
 
  private:
-  struct url_data context_;
+  url_data context_;
 };
 
 }  // namespace url

package/src/headers/18/node_v8.h

@@ -0,0 +1,41 @@
+#ifndef SRC_NODE_V8_H_
+#define SRC_NODE_V8_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+struct InternalFieldInfo;
+
+namespace v8_utils {
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Environment* env, v8::Local<v8::Object> obj);
+
+  SERIALIZABLE_OBJECT_METHODS()
+  static constexpr FastStringKey type_name{"node::v8::BindingData"};
+  static constexpr EmbedderObjectType type_int =
+      EmbedderObjectType::k_v8_binding_data;
+
+  AliasedFloat64Array heap_statistics_buffer;
+  AliasedFloat64Array heap_space_statistics_buffer;
+  AliasedFloat64Array heap_code_statistics_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+};
+
+}  // namespace v8_utils
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_H_

package/src/headers/{12 → 18}/node_v8_platform-inl.h

@@ -8,10 +8,12 @@
 #include "env-inl.h"
 #include "node.h"
 #include "node_metadata.h"
+#include "node_platform.h"
 #include "node_options.h"
 #include "tracing/node_trace_writer.h"
 #include "tracing/trace_event.h"
 #include "tracing/traced_value.h"
+#include "util.h"
 
 namespace node {
 
@@ -79,8 +81,12 @@ class NodeTraceStateObserver
 };
 
 struct V8Platform {
+  bool initialized_ = false;
+
 #if NODE_USE_V8_PLATFORM
   inline void Initialize(int thread_pool_size) {
+    CHECK(!initialized_);
+    initialized_ = true;
     tracing_agent_ = std::make_unique<tracing::Agent>();
     node::tracing::TraceEventHelper::SetAgent(tracing_agent_.get());
     node::tracing::TracingController* controller =
@@ -99,6 +105,10 @@ struct V8Platform {
   }
 
   inline void Dispose() {
+    if (!initialized_)
+      return;
+    initialized_ = false;
+
     StopTracingAgent();
     platform_->Shutdown();
     delete platform_;

package/src/headers/{13 → 18}/node_version.h

@@ -22,14 +22,14 @@
 #ifndef SRC_NODE_VERSION_H_
 #define SRC_NODE_VERSION_H_
 
-#define NODE_MAJOR_VERSION 13
-#define NODE_MINOR_VERSION 14
-#define NODE_PATCH_VERSION 1
+#define NODE_MAJOR_VERSION 18
+#define NODE_MINOR_VERSION 3
+#define NODE_PATCH_VERSION 0
 
 #define NODE_VERSION_IS_LTS 0
 #define NODE_VERSION_LTS_CODENAME ""
 
-#define NODE_VERSION_IS_RELEASE 0
+#define NODE_VERSION_IS_RELEASE 1
 
 #ifndef NODE_STRINGIFY
 #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
@@ -84,15 +84,15 @@
  * if it can be made ABI compatible with the previous version.
  *
  * The registry of used NODE_MODULE_VERSION numbers is located at
- *   https://github.com/nodejs/node/blob/master/doc/abi_version_registry.json
+ *   https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json
  * Extenders, embedders and other consumers of Node.js that require ABI
  * version matching should open a pull request to reserve a number in this
  * registry.
  */
-#define NODE_MODULE_VERSION 79
+#define NODE_MODULE_VERSION 108
 
 // The NAPI_VERSION provided by this version of the runtime. This is the version
 // which the Node binary being built supports.
-#define NAPI_VERSION  6
+#define NAPI_VERSION  8
 
 #endif  // SRC_NODE_VERSION_H_

package/src/headers/18/node_wasm_web_api.h

@@ -0,0 +1,55 @@
+#ifndef SRC_NODE_WASM_WEB_API_H_
+#define SRC_NODE_WASM_WEB_API_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object-inl.h"
+#include "v8.h"
+
+namespace node {
+namespace wasm_web_api {
+
+// Wrapper for interacting with a v8::WasmStreaming instance from JavaScript.
+class WasmStreamingObject final : public BaseObject {
+ public:
+  static v8::Local<v8::Function> Initialize(Environment* env);
+
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(WasmStreamingObject)
+  SET_SELF_SIZE(WasmStreamingObject)
+
+  static v8::MaybeLocal<v8::Object> Create(
+      Environment* env, std::shared_ptr<v8::WasmStreaming> streaming);
+
+ private:
+  WasmStreamingObject(Environment* env, v8::Local<v8::Object> object)
+      : BaseObject(env, object) {
+    MakeWeak();
+  }
+
+  ~WasmStreamingObject() override {}
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Push(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Finish(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Abort(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  std::shared_ptr<v8::WasmStreaming> streaming_;
+  size_t wasm_size_ = 0;
+};
+
+// This is a v8::WasmStreamingCallback implementation that must be passed to
+// v8::Isolate::SetWasmStreamingCallback when setting up the isolate in order to
+// enable the WebAssembly.(compile|instantiate)Streaming APIs.
+void StartStreamingCompilation(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+}  // namespace wasm_web_api
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_WASM_WEB_API_H_

package/src/headers/{10 → 18}/node_win32_etw_provider-inl.h

@@ -111,13 +111,12 @@ extern int events_enabled;
                              dataDescriptors);                                \
   CHECK_EQ(status, ERROR_SUCCESS);
 
-#define ETW_WRITE_EMPTY_EVENT(eventDescriptor)                                \
-  DWORD status = event_write(node_provider,                                   \
-                             &eventDescriptor,                                \
-                             0,                                               \
-                             NULL);  // NOLINT (readability/null_usage)       \
-  CHECK_EQ(status, ERROR_SUCCESS);
+// NOLINTNEXTLINE (readability/null_usage)
+#define NULL_NOLINT NULL
 
+#define ETW_WRITE_EMPTY_EVENT(eventDescriptor)                                 \
+  DWORD status = event_write(node_provider, &eventDescriptor, 0, NULL_NOLINT); \
+  CHECK_EQ(status, ERROR_SUCCESS);
 
 void NODE_HTTP_SERVER_REQUEST(node_dtrace_http_server_request_t* req,
     node_dtrace_connection_t* conn, const char* remote, int port,
@@ -271,6 +270,8 @@ void NODE_V8SYMBOL_ADD(LPCSTR symbol,
 }
 #undef SETSYMBUF
 
+#undef NULL_NOLINT
+
 
 bool NODE_HTTP_SERVER_REQUEST_ENABLED() { return events_enabled > 0; }
 bool NODE_HTTP_SERVER_RESPONSE_ENABLED() { return events_enabled > 0; }