add virtual builtins stats (#1369)

Author: astrophysik

runtime/interface.cpp

@@ -2297,9 +2297,9 @@ static void init_interface_lib() {
 
 static void init_runtime_libs() {
   // init_curl_lib() lazy called in runtime
-  runtime_builtins_stats::init_request_stats();
   init_instance_cache_lib();
   init_confdata_functions_lib();
+  runtime_builtins_stats::init_request_stats();
 
   init_memcache_lib();
   init_mysql_lib();

runtime/openssl.cpp

@@ -37,6 +37,7 @@
 #include "runtime/datetime/datetime_functions.h"
 #include "runtime/files.h"
 #include "runtime/net_events.h"
+#include "runtime/runtime-builtin-stats.h"
 #include "runtime/streams.h"
 #include "runtime/string_functions.h"
 #include "runtime/url.h"
@@ -1737,11 +1738,23 @@ void openssl_add_method(const OBJ_NAME* name, void* arg) {
 
 Optional<string> eval_cipher(CipherCtx::cipher_action action, const string& data, const string& method, const string& key, int64_t options, const string& iv,
                              string& tag, const string& aad) {
+  constexpr static auto record_openssl_builtin_call{[](CipherCtx::cipher_action action, const string& method) noexcept {
+    constexpr static std::string_view encrypt_builtin_name = "openssl_encrypt";
+    constexpr static std::string_view decrypt_builtin_name = "openssl_decrypt";
+    const std::string_view builtin_name = action == CipherCtx::encrypt ? encrypt_builtin_name : decrypt_builtin_name;
+    kphp::stl::string<kphp::memory::script_allocator> virtual_builtin_name;
+    virtual_builtin_name.reserve(builtin_name.size() + 1 + method.size());
+    virtual_builtin_name.append(builtin_name.data()).append("_").append(method.c_str());
+    runtime_builtins_stats::save_virtual_builtin_call_stats(virtual_builtin_name);
+  }};
+
   CipherCtx cipher{method, options, action};
   if (cipher && cipher.init(key, iv, tag) && cipher.update(data, aad) && cipher.finalize()) {
     if (action == CipherCtx::cipher_action::encrypt && !cipher.make_tag(tag)) {
       return false;
     }
+    // record only success calls
+    record_openssl_builtin_call(action, method);
     return cipher.flush_result();
   }
   return false;

runtime/runtime-builtin-stats.h

@@ -4,41 +4,51 @@
 
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <optional>
 #include <string_view>
 
 #include "runtime-common/core/allocator/script-allocator.h"
 #include "runtime-common/core/std/containers.h"
 
-#define SAVE_BUILTIN_CALL_STATS(builtin_name, builtin_call)                                                                                                    \
-  (!runtime_builtins_stats::impl_::is_request_stats_enabled ? 0 : (*runtime_builtins_stats::request_stats.stats)[std::string_view(builtin_name)]++,            \
-   builtin_call)
+template<>
+struct std::hash<kphp::stl::string<kphp::memory::script_allocator>> {
+  std::size_t operator()(const kphp::stl::string<kphp::memory::script_allocator>& s) const noexcept {
+    std::string_view view{s.c_str(), s.size()};
+    return std::hash<std::string_view>{}(view);
+  }
+};
 
 namespace runtime_builtins_stats {
-
-namespace impl_ {
-inline bool is_request_stats_enabled = false;
-} // namespace impl_
-
 inline bool is_server_option_enabled = false;
 
 struct request_stats_t {
-  std::optional<kphp::stl::unordered_map<std::string_view, int64_t, kphp::memory::script_allocator>> stats{};
+  kphp::stl::unordered_map<std::string_view, int64_t, kphp::memory::script_allocator> builtin_stats{};
+  kphp::stl::unordered_map<kphp::stl::string<kphp::memory::script_allocator>, int64_t, kphp::memory::script_allocator> virtual_builtin_stats{};
 };
 
-inline request_stats_t request_stats;
+inline std::optional<request_stats_t> request_stats;
 
 inline void init_request_stats() noexcept {
-  php_assert(!request_stats.stats.has_value());
-  impl_::is_request_stats_enabled = is_server_option_enabled;
-  request_stats.stats.emplace();
+  php_assert(!request_stats.has_value());
+  if (is_server_option_enabled) {
+    request_stats.emplace();
+  }
 }
 
 inline void reset_request_stats() noexcept {
-  php_assert(request_stats.stats.has_value());
-  impl_::is_request_stats_enabled = false;
-  request_stats.stats.reset();
+  request_stats.reset();
 }
 
+inline void save_virtual_builtin_call_stats(const kphp::stl::string<kphp::memory::script_allocator>& builtin_call) noexcept {
+  if (runtime_builtins_stats::request_stats.has_value()) {
+    (*runtime_builtins_stats::request_stats).virtual_builtin_stats[builtin_call]++;
+  }
+}
 } // namespace runtime_builtins_stats
+
+#define SAVE_BUILTIN_CALL_STATS(builtin_name, builtin_call)                                                                                                    \
+  (!runtime_builtins_stats::request_stats.has_value() ? 0 : (*runtime_builtins_stats::request_stats).builtin_stats[std::string_view(builtin_name)]++,          \
+   builtin_call)

runtime/streams.cpp

@@ -13,6 +13,7 @@
 #include "runtime/allocator.h"
 #include "runtime/array_functions.h"
 #include "runtime/critical_section.h"
+#include "runtime/runtime-builtin-stats.h"
 
 DEFINE_VERBOSITY(streams);
 
@@ -54,12 +55,18 @@ static const stream_functions* get_stream_functions_from_url(const string& url,
   tvkprintf(streams, 2, "PHP streams: %s is processing stream %.200s\n", invoker_name, url.c_str());
 
   void* res = memmem(static_cast<const void*>(url.c_str()), url.size(), static_cast<const void*>("://"), 3);
+
+  const stream_functions* functions_table{default_stream_functions};
   if (res != nullptr) {
     const char* wrapper_end = static_cast<const char*>(res);
-    return get_stream_functions(string(url.c_str(), static_cast<string::size_type>(wrapper_end - url.c_str())));
+    functions_table = get_stream_functions(string(url.c_str(), static_cast<string::size_type>(wrapper_end - url.c_str())));
   }
 
-  return default_stream_functions;
+  kphp::stl::string<kphp::memory::script_allocator> builtin_name{invoker_name};
+  builtin_name.append("_").append(functions_table->name.c_str());
+  runtime_builtins_stats::save_virtual_builtin_call_stats(builtin_name);
+
+  return functions_table;
 }
 
 mixed f$stream_context_create(const mixed& options) {

server/server-stats.cpp

@@ -637,7 +637,7 @@ void ServerStats::after_fork(pid_t worker_pid, uint64_t active_connections, uint
 }
 
 void ServerStats::add_request_stats(double script_time_sec, double net_time_sec, double script_max_running_interval_sec, double script_init_time_sec, double connection_process_time_sec,
-                                    int64_t script_queries, int64_t long_script_queries, const memory_resource::MemoryStats &script_memory_stats, const runtime_builtins_stats::request_stats_t &builtin_stats,
+                                    int64_t script_queries, int64_t long_script_queries, const memory_resource::MemoryStats &script_memory_stats, const std::optional<runtime_builtins_stats::request_stats_t> &builtin_stats,
                                     int64_t curl_total_allocated, process_rusage_t script_rusage, script_error_t error) noexcept {
   auto &stats = worker_type_ == WorkerType::job_worker ? shared_stats_->job_workers : shared_stats_->general_workers;
   const auto script_time = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::duration<double>(script_time_sec));

server/server-stats.h

@@ -23,7 +23,7 @@ class ServerStats : vk::not_copyable {
 
   void add_request_stats(double script_time_sec, double net_time_sec, double script_max_running_interval_sec, double script_init_time_sec, double connection_process_time_sec,
                          int64_t script_queries, int64_t long_script_queries,
-                         const memory_resource::MemoryStats &script_memory_stats, const runtime_builtins_stats::request_stats_t &builtin_stats,
+                         const memory_resource::MemoryStats &script_memory_stats,  const std::optional<runtime_builtins_stats::request_stats_t> &builtin_stats,
                          int64_t curl_total_allocated, process_rusage_t script_rusage, script_error_t error) noexcept;
   void add_job_stats(double job_wait_time_sec, int64_t request_memory_used, int64_t request_real_memory_used, int64_t response_memory_used,
                      int64_t response_real_memory_used) noexcept;

server/statshouse/statshouse-manager.cpp

@@ -109,7 +109,7 @@ void StatsHouseManager::generic_cron_check_if_tag_host_needed() {
 }
 
 void StatsHouseManager::add_request_stats(uint64_t script_time_ns, uint64_t net_time_ns, uint64_t script_max_running_interval_ns,  script_error_t error,
-                                          const memory_resource::MemoryStats &script_memory_stats, const runtime_builtins_stats::request_stats_t &builtin_stats,
+                                          const memory_resource::MemoryStats &script_memory_stats, const std::optional<runtime_builtins_stats::request_stats_t> &builtin_stats,
                                           uint64_t script_queries, uint64_t long_script_queries,
                                           uint64_t script_user_time_ns, uint64_t script_system_time_ns,
                                           uint64_t script_init_time, uint64_t http_connection_process_time,
@@ -141,10 +141,13 @@ void StatsHouseManager::add_request_stats(uint64_t script_time_ns, uint64_t net_
     client.metric("kphp_by_host_request_errors", true).tag(status).tag(worker_type).write_count(1);
   }
 
-  if (builtin_stats.stats.has_value()) {
-    for (const auto& [builtin_name, call_number] : *builtin_stats.stats) {
+  if (builtin_stats.has_value()) {
+    for (const auto& [builtin_name, call_number] : (*builtin_stats).builtin_stats) {
       client.metric("kphp_request_builtin_stats").tag(builtin_name).write_value(call_number);
     }
+    for (const auto& [virtual_builtin_name, call_number] : (*builtin_stats).virtual_builtin_stats) {
+      client.metric("kphp_request_builtin_stats").tag(virtual_builtin_name.c_str()).write_value(call_number);
+    }
   }
 
   client.metric("kphp_memory_script_usage").tag("used").tag(worker_type).write_value(script_memory_stats.memory_used);

server/statshouse/statshouse-manager.h

@@ -59,7 +59,7 @@ class StatsHouseManager : vk::not_copyable {
   }
 
   void add_request_stats(uint64_t script_time_ns, uint64_t net_time_ns, uint64_t script_max_running_interval_ns, script_error_t error,
-                         const memory_resource::MemoryStats &script_memory_stats, const runtime_builtins_stats::request_stats_t &builtin_stats,
+                         const memory_resource::MemoryStats &script_memory_stats, const std::optional<runtime_builtins_stats::request_stats_t> &builtin_stats,
                          uint64_t script_queries, uint64_t long_script_queries,
                          uint64_t script_user_time_ns, uint64_t script_system_time_ns,
                          uint64_t script_init_time, uint64_t http_connection_process_time,