changed some of the runtime logs to server logs (#1285)

Danil42Russia · DrDet · web-flow · commit 636247357601 · 2025-06-09T17:36:44.000+03:00
Co-authored-by: Denis Vaksman &lt;dr.denisv2016@yandex.ru&gt;
diff --git a/runtime-common/core/memory-resource/resource_allocator.h b/runtime-common/core/memory-resource/resource_allocator.h
@@ -37,7 +37,7 @@ class resource_allocator {
     static_assert(sizeof(value_type) <= max_value_type_size(), "memory limit");
     auto result = static_cast<value_type*>(memory_resource_.allocate(sizeof(value_type) * size));
     if (unlikely(!result)) {
-      php_critical_error("not enough memory to continue");
+      runtime_critical_error("not enough memory to continue");
     }
     return result;
   }
diff --git a/runtime-common/core/utils/kphp-assert-core.h b/runtime-common/core/utils/kphp-assert-core.h
@@ -4,11 +4,18 @@
 
 #include "common/wrappers/likely.h"
 
+// For reporting php logic related errors happened during script execution
 void php_debug(char const* message, ...) __attribute__((format(printf, 1, 2)));
 void php_notice(char const* message, ...) __attribute__((format(printf, 1, 2)));
 void php_warning(char const* message, ...) __attribute__((format(printf, 1, 2)));
 void php_error(char const* message, ...) __attribute__((format(printf, 1, 2)));
 
+// For reporting internal runtime errors happened during script execution
+// void runtime_debug(char const* message, ...) __attribute__((format(printf, 1, 2)));
+// void runtime_notice(char const* message, ...) __attribute__((format(printf, 1, 2)));
+// void runtime_warning(char const* message, ...) __attribute__((format(printf, 1, 2)));
+void runtime_error(char const* message, ...) __attribute__((format(printf, 1, 2)));
+
 [[noreturn]] void php_assert__(const char* msg, const char* file, int line);
 [[noreturn]] void critical_error_handler();
 
@@ -24,3 +31,9 @@ void php_error(char const* message, ...) __attribute__((format(printf, 1, 2)));
     php_error("Critical error \"" format "\" in file %s on line %d", ##__VA_ARGS__, __FILE__, __LINE__);                                                       \
     critical_error_handler();                                                                                                                                  \
   } while (0)
+
+#define runtime_critical_error(format, ...)                                                                                                                    \
+  do {                                                                                                                                                         \
+    runtime_error("Critical error \"" format "\" in file %s on line %d", ##__VA_ARGS__, __FILE__, __LINE__);                                                   \
+    critical_error_handler();                                                                                                                                  \
+  } while (0)
diff --git a/runtime-light/utils/php_assert.cpp b/runtime-light/utils/php_assert.cpp
@@ -62,6 +62,13 @@ void php_error(char const* message, ...) {
   va_end(args);
 }
 
+void runtime_error(char const* message, ...) {
+  va_list args;
+  va_start(args, message);
+  php_warning_impl(false, std::to_underlying(LogLevel::Error), message, args); // TODO: fix error code and think about internal / user errors separation in K2
+  va_end(args);
+}
+
 void php_assert__(const char* msg, const char* file, int line) {
   php_error("Assertion \"%s\" failed in file %s on line %d", msg, file, line);
   critical_error_handler();
diff --git a/runtime/allocator.cpp b/runtime/allocator.cpp
@@ -104,7 +104,7 @@ void* allocate(size_t size) noexcept {
     return heap_replacer->allocate(size);
   }
   if (unlikely(!script_allocator_enabled)) {
-    php_critical_error("Trying to call allocate for non runned script, n = %zu", size);
+    runtime_critical_error("Trying to call allocate for non runned script, n = %zu", size);
     return nullptr;
   }
 
@@ -118,7 +118,7 @@ void* allocate0(size_t size) noexcept {
     return heap_replacer->allocate0(size);
   }
   if (unlikely(!script_allocator_enabled)) {
-    php_critical_error("Trying to call allocate0 for non runned script, n = %zu", size);
+    runtime_critical_error("Trying to call allocate0 for non runned script, n = %zu", size);
     return nullptr;
   }
 
@@ -132,7 +132,7 @@ void* reallocate(void* mem, size_t new_size, size_t old_size) noexcept {
     return heap_replacer->reallocate(mem, new_size, old_size);
   }
   if (unlikely(!script_allocator_enabled)) {
-    php_critical_error("Trying to call reallocate for non runned script, p = %p, new_size = %zu, old_size = %zu", mem, new_size, old_size);
+    runtime_critical_error("Trying to call reallocate for non runned script, p = %p, new_size = %zu, old_size = %zu", mem, new_size, old_size);
     return mem;
   }
 
@@ -277,7 +277,7 @@ void* memalign(size_t alignment, size_t size) {
 void* operator new(size_t size) {
   auto* res = std::malloc(size);
   if (!res) {
-    php_critical_error("nullptr from malloc");
+    runtime_critical_error("nullptr from malloc");
   }
   return res;
 }
diff --git a/runtime/inter-process-mutex.cpp b/runtime/inter-process-mutex.cpp
@@ -43,7 +43,7 @@ void handle_lock_error(pid_t* lock, const char* what) noexcept {
       }
     }
   } else if (errno != EAGAIN) {
-    php_critical_error("Got unexpected error from futex %s: %s", what, std::strerror(errno));
+    runtime_critical_error("Got unexpected error from futex %s: %s", what, std::strerror(errno));
   }
 }
 
@@ -95,7 +95,7 @@ void inter_process_mutex::unlock() noexcept {
   const pid_t tid = get_main_thread_id();
   if (!__sync_bool_compare_and_swap(&lock_, tid, 0)) {
     if (futex(&lock_, FUTEX_UNLOCK_PI)) {
-      php_critical_error("Got unexpected error from futex unlock: %s", std::strerror(errno));
+      runtime_critical_error("Got unexpected error from futex unlock: %s", std::strerror(errno));
     }
   }
   dl::leave_critical_section();
diff --git a/runtime/memory_resource_impl/monotonic_runtime_buffer_resource.cpp b/runtime/memory_resource_impl/monotonic_runtime_buffer_resource.cpp
@@ -19,21 +19,21 @@ void monotonic_buffer_resource::critical_dump(void* mem, size_t size) const noex
     dl::write_last_malloc_replacement_stacktrace(malloc_replacement_stacktrace_buf.data() + strlen(descr),
                                                  malloc_replacement_stacktrace_buf.size() - strlen(descr));
   }
-  php_critical_error("Found unexpected memory piece:\n"
-                     "ptr:                  %p\n"
-                     "size:                 %zu\n"
-                     "memory_begin:         %p\n"
-                     "memory_current:       %p\n"
-                     "memory_end:           %p\n"
-                     "memory_limit:         %zu\n"
-                     "memory_used:          %zu\n"
-                     "max_memory_used:      %zu\n"
-                     "real_memory_used:     %zu\n"
-                     "max_real_memory_used: %zu\n"
-                     "is_malloc_replaced:   %d\n"
-                     "%s",
-                     mem, size, memory_begin_, memory_current_, memory_end_, stats_.memory_limit, stats_.memory_used, stats_.max_memory_used,
-                     stats_.real_memory_used, stats_.max_real_memory_used, dl::is_malloc_replaced(), malloc_replacement_stacktrace_buf.data());
+  runtime_critical_error("Found unexpected memory piece:\n"
+                         "ptr:                  %p\n"
+                         "size:                 %zu\n"
+                         "memory_begin:         %p\n"
+                         "memory_current:       %p\n"
+                         "memory_end:           %p\n"
+                         "memory_limit:         %zu\n"
+                         "memory_used:          %zu\n"
+                         "max_memory_used:      %zu\n"
+                         "real_memory_used:     %zu\n"
+                         "max_real_memory_used: %zu\n"
+                         "is_malloc_replaced:   %d\n"
+                         "%s",
+                         mem, size, memory_begin_, memory_current_, memory_end_, stats_.memory_limit, stats_.memory_used, stats_.max_memory_used,
+                         stats_.real_memory_used, stats_.max_real_memory_used, dl::is_malloc_replaced(), malloc_replacement_stacktrace_buf.data());
 }
 
 void monotonic_buffer_resource::raise_oom(size_t size) const noexcept {
diff --git a/runtime/net_events.cpp b/runtime/net_events.cpp
@@ -129,7 +129,7 @@ kphp_event_timer* allocate_event_timer(double wakeup_time, int wakeup_callback_i
         dl::reallocate(event_timers_heap, sizeof(kphp_event_timer*) * 2 * event_timers_max_heap_size, sizeof(kphp_event_timer*) * event_timers_max_heap_size));
     event_timers_max_heap_size *= 2;
     if (event_timers_max_heap_size > EVENT_TIMERS_HEAP_INDEX_MASK) {
-      php_critical_error("maximum number of event timers exceeded");
+      runtime_critical_error("maximum number of event timers exceeded");
     }
   }
   i = event_timer_heap_move_up(et->wakeup_time, i);
diff --git a/runtime/php_assert.cpp b/runtime/php_assert.cpp
@@ -31,6 +31,7 @@
 
 #include "server/json-logger.h"
 #include "server/php-engine-vars.h"
+#include "server/server-log.h"
 
 const char* engine_tag = "[";
 long long engine_tag_number = 0;
@@ -164,10 +165,11 @@ static void php_warning_impl(bool out_of_memory, int error_type, char const* mes
   }
 
   if (is_demangled_stacktrace_logs_enabled) {
-    vk::singleton<JsonLogger>::get().write_log_with_demangled_backtrace(buf, error_type, cur_time, buffer, nptrs,
-                                                                        out_of_memory || die_on_fail || error_type == E_ERROR);
+    vk::singleton<JsonLogger>::get().write_log_with_demangled_backtrace(
+        buf, error_type, cur_time, buffer, nptrs, out_of_memory || die_on_fail || error_type == E_ERROR || error_type == static_cast<int>(ServerLog::Critical));
   } else {
-    vk::singleton<JsonLogger>::get().write_log(buf, error_type, cur_time, buffer, nptrs, out_of_memory || die_on_fail || error_type == E_ERROR);
+    vk::singleton<JsonLogger>::get().write_log(buf, error_type, cur_time, buffer, nptrs,
+                                               out_of_memory || die_on_fail || error_type == E_ERROR || error_type == static_cast<int>(ServerLog::Critical));
   }
 
   if (die_on_fail) {
@@ -205,6 +207,13 @@ void php_out_of_memory_warning(char const* message, ...) {
   va_end(args);
 }
 
+void runtime_error(char const* message, ...) {
+  va_list args;
+  va_start(args, message);
+  php_warning_impl(false, static_cast<int>(ServerLog::Critical), message, args);
+  va_end(args);
+}
+
 const char* php_uncaught_exception_error(const class_instance<C$Throwable>& ex) noexcept {
   const int64_t current_time = time(nullptr);
   const char* message = ex->$message.empty() ? "(empty)" : ex->$message.c_str();
diff --git a/server/php-engine.cpp b/server/php-engine.cpp
@@ -1031,7 +1031,6 @@ int rpcx_execute(connection *c, int op, raw_message *raw) {
       assert(result_len >= 0);
 
       if (result_len == 0) {
-        log_server_warning("Got empty RPC result from %s, op = 0x%08x", pid_to_print(&remote_pid), static_cast<unsigned>(op));
         return 0;
       }
 

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ class resource_allocator {`
`37`	`37`	`static_assert(sizeof(value_type) <= max_value_type_size(), "memory limit");`
`38`	`38`	`auto result = static_cast<value_type>(memory_resource_.allocate(sizeof(value_type) size));`
`39`	`39`	`if (unlikely(!result)) {`
`40`		`- php_critical_error("not enough memory to continue");`
	`40`	`+ runtime_critical_error("not enough memory to continue");`
`41`	`41`	`}`
`42`	`42`	`return result;`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ void* allocate(size_t size) noexcept {`
`104`	`104`	`return heap_replacer->allocate(size);`
`105`	`105`	`}`
`106`	`106`	`if (unlikely(!script_allocator_enabled)) {`
`107`		`- php_critical_error("Trying to call allocate for non runned script, n = %zu", size);`
	`107`	`+ runtime_critical_error("Trying to call allocate for non runned script, n = %zu", size);`
`108`	`108`	`return nullptr;`
`109`	`109`	`}`
`110`	`110`
`@@ -118,7 +118,7 @@ void* allocate0(size_t size) noexcept {`
`118`	`118`	`return heap_replacer->allocate0(size);`
`119`	`119`	`}`
`120`	`120`	`if (unlikely(!script_allocator_enabled)) {`
`121`		`- php_critical_error("Trying to call allocate0 for non runned script, n = %zu", size);`
	`121`	`+ runtime_critical_error("Trying to call allocate0 for non runned script, n = %zu", size);`
`122`	`122`	`return nullptr;`
`123`	`123`	`}`
`124`	`124`
`@@ -132,7 +132,7 @@ void* reallocate(void* mem, size_t new_size, size_t old_size) noexcept {`
`132`	`132`	`return heap_replacer->reallocate(mem, new_size, old_size);`
`133`	`133`	`}`
`134`	`134`	`if (unlikely(!script_allocator_enabled)) {`
`135`		`- php_critical_error("Trying to call reallocate for non runned script, p = %p, new_size = %zu, old_size = %zu", mem, new_size, old_size);`
	`135`	`+ runtime_critical_error("Trying to call reallocate for non runned script, p = %p, new_size = %zu, old_size = %zu", mem, new_size, old_size);`
`136`	`136`	`return mem;`
`137`	`137`	`}`
`138`	`138`
`@@ -277,7 +277,7 @@ void* memalign(size_t alignment, size_t size) {`
`277`	`277`	`void* operator new(size_t size) {`
`278`	`278`	`auto* res = std::malloc(size);`
`279`	`279`	`if (!res) {`
`280`		`- php_critical_error("nullptr from malloc");`
	`280`	`+ runtime_critical_error("nullptr from malloc");`
`281`	`281`	`}`
`282`	`282`	`return res;`
`283`	`283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ void handle_lock_error(pid_t* lock, const char* what) noexcept {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`} else if (errno != EAGAIN) {`
`46`		`- php_critical_error("Got unexpected error from futex %s: %s", what, std::strerror(errno));`
	`46`	`+ runtime_critical_error("Got unexpected error from futex %s: %s", what, std::strerror(errno));`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`@@ -95,7 +95,7 @@ void inter_process_mutex::unlock() noexcept {`
`95`	`95`	`const pid_t tid = get_main_thread_id();`
`96`	`96`	`if (!__sync_bool_compare_and_swap(&lock_, tid, 0)) {`
`97`	`97`	`if (futex(&lock_, FUTEX_UNLOCK_PI)) {`
`98`		`- php_critical_error("Got unexpected error from futex unlock: %s", std::strerror(errno));`
	`98`	`+ runtime_critical_error("Got unexpected error from futex unlock: %s", std::strerror(errno));`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`	`dl::leave_critical_section();`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ kphp_event_timer* allocate_event_timer(double wakeup_time, int wakeup_callback_i`
`129`	`129`	`dl::reallocate(event_timers_heap, sizeof(kphp_event_timer) 2 * event_timers_max_heap_size, sizeof(kphp_event_timer) event_timers_max_heap_size));`
`130`	`130`	`event_timers_max_heap_size *= 2;`
`131`	`131`	`if (event_timers_max_heap_size > EVENT_TIMERS_HEAP_INDEX_MASK) {`
`132`		`- php_critical_error("maximum number of event timers exceeded");`
	`132`	`+ runtime_critical_error("maximum number of event timers exceeded");`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`i = event_timer_heap_move_up(et->wakeup_time, i);`
Original file line number	Diff line number	Diff line change
`@@ -1031,7 +1031,6 @@ int rpcx_execute(connection c, int op, raw_message raw) {`
`1031`	`1031`	`assert(result_len >= 0);`
`1032`	`1032`
`1033`	`1033`	`if (result_len == 0) {`
`1034`		`- log_server_warning("Got empty RPC result from %s, op = 0x%08x", pid_to_print(&remote_pid), static_cast<unsigned>(op));`
`1035`	`1034`	`return 0;`
`1036`	`1035`	`}`
`1037`	`1036`