Make use of fast_shutdown to avoid freeing overhead

bwoebi · bwoebi · commit a3e585adb6f5 · 2025-09-22T20:00:59.000+02:00
Signed-off-by: Bob Weinand &lt;bob.weinand@datadoghq.com&gt;
diff --git a/ext/auto_flush.c b/ext/auto_flush.c
@@ -19,14 +19,14 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(ddtrace);
 
-ZEND_RESULT_CODE ddtrace_flush_tracer(bool force_on_startup, bool collect_cycles) {
+ZEND_RESULT_CODE ddtrace_flush_tracer(bool force_on_startup, bool collect_cycles, bool fast_shutdown) {
     bool success = true;
 
     ddog_TracesBytes *traces = ddog_get_traces();
     if (collect_cycles) {
-        ddtrace_serialize_closed_spans_with_cycle(traces);
+        ddtrace_serialize_closed_spans_with_cycle(traces, fast_shutdown);
     } else {
-        ddtrace_serialize_closed_spans(traces);
+        ddtrace_serialize_closed_spans(traces, fast_shutdown);
     }
 
     // Prevent traces from requests not executing any PHP code:
@@ -113,7 +113,7 @@ ZEND_RESULT_CODE ddtrace_flush_tracer(bool force_on_startup, bool collect_cycles
 DDTRACE_PUBLIC void ddtrace_close_all_spans_and_flush()
 {
     ddtrace_close_all_open_spans(true);
-    ddtrace_flush_tracer(true, true);
+    ddtrace_flush_tracer(true, true, false);
 }
 
 #define DEFAULT_UDS_PATH "/var/run/datadog/apm.socket"
diff --git a/ext/auto_flush.h b/ext/auto_flush.h
@@ -5,7 +5,7 @@
 #include <php.h>
 #include <stdbool.h>
 
-ZEND_RESULT_CODE ddtrace_flush_tracer(bool force_on_startup, bool collect_cycles);
+ZEND_RESULT_CODE ddtrace_flush_tracer(bool force_on_startup, bool collect_cycles, bool fast_shutdown);
 
 // This function is exported and used by appsec
 DDTRACE_PUBLIC void ddtrace_close_all_spans_and_flush(void);
diff --git a/ext/ddtrace.c b/ext/ddtrace.c
@@ -1775,8 +1775,8 @@ static void dd_clean_globals(void) {
 #endif
 }
 
-static void dd_shutdown_hooks_and_observer(void) {
-    zai_hook_clean();
+static void dd_shutdown_hooks_and_observer(bool fast_shutdown) {
+    zai_hook_clean(fast_shutdown);
 
 #if PHP_VERSION_ID >= 80000 && PHP_VERSION_ID < 80200
 #if PHP_VERSION_ID < 80100
@@ -1797,7 +1797,7 @@ static void dd_shutdown_hooks_and_observer(void) {
 #endif
 }
 
-void dd_force_shutdown_tracing(void) {
+void dd_force_shutdown_tracing(bool fast_shutdown) {
     DDTRACE_G(in_shutdown) = true;
 
     zend_try {
@@ -1807,7 +1807,7 @@ void dd_force_shutdown_tracing(void) {
     } zend_end_try();
 
     zend_try {
-        if (ddtrace_flush_tracer(false, true) == FAILURE) {
+        if (ddtrace_flush_tracer(false, true, fast_shutdown) == FAILURE) {
             LOG(WARN, "Unable to flush the tracer");
         }
     } zend_catch {
@@ -1818,7 +1818,7 @@ void dd_force_shutdown_tracing(void) {
     ddtrace_disable_tracing_in_current_request();  // implicitly calling dd_clean_globals
 
     // The hooks shall not be reset, just disabled at runtime.
-    dd_shutdown_hooks_and_observer();
+    dd_shutdown_hooks_and_observer(fast_shutdown);
 
     DDTRACE_G(in_shutdown) = false;
 }
@@ -1832,16 +1832,31 @@ static void dd_finalize_sidecar_lifecycle(bool clear_id) {
 static PHP_RSHUTDOWN_FUNCTION(ddtrace) {
     UNUSED(module_number, type);
 
+    // We deliberately select to not free some data structures, as to avoid the overhead of freeing them.
+    // Just proper destruction can have significant and easily measurable overhead on applications.
+    // Prior to PHP 7.2 fast shutdown was an opcache only feature
+#if ZEND_DEBUG || PHP_VERSION_ID < 70200
+    bool fast_shutdown = 0;
+#elif defined(__SANITIZE_ADDRESS__)
+    char *force_fast_shutdown = getenv("ZEND_ASAN_FORCE_FAST_SHUTDOWN");
+    bool fast_shutdown = (
+        is_zend_mm()
+        || (force_fast_shutdown && ZEND_ATOL(force_fast_shutdown))
+    ) && !EG(full_tables_cleanup);
+#else
+    bool fast_shutdown = is_zend_mm() && !EG(full_tables_cleanup);
+#endif
+
     zend_hash_destroy(&DDTRACE_G(traced_spans));
 
     // this needs to be done before dropping the spans
     // run unconditionally because ddtrace may've been disabled mid-request
     ddtrace_exec_handlers_rshutdown();
 
     if (get_DD_TRACE_ENABLED()) {
-        dd_force_shutdown_tracing();
+        dd_force_shutdown_tracing(fast_shutdown);
     } else if (!ddtrace_disable) {
-        dd_shutdown_hooks_and_observer();
+        dd_shutdown_hooks_and_observer(fast_shutdown);
     }
 
     if (DDTRACE_G(remote_config_state)) {
@@ -1851,7 +1866,9 @@ static PHP_RSHUTDOWN_FUNCTION(ddtrace) {
     if (!ddtrace_disable) {
         ddtrace_autoload_rshutdown();
 
-        OBJ_RELEASE(&DDTRACE_G(active_stack)->std);
+        if (!fast_shutdown) {
+            OBJ_RELEASE(&DDTRACE_G(active_stack)->std);
+        }
         DDTRACE_G(active_stack) = NULL;
     }
 
@@ -2344,7 +2361,7 @@ PHP_FUNCTION(dd_trace_serialize_closed_spans) {
     ddtrace_mark_all_span_stacks_flushable();
 
     ddog_TracesBytes *traces = ddog_get_traces();
-    ddtrace_serialize_closed_spans_with_cycle(traces);
+    ddtrace_serialize_closed_spans_with_cycle(traces, false);
 
     zval traces_zv = dd_serialize_rust_traces_to_zval(traces);
 
@@ -3221,7 +3238,7 @@ PHP_FUNCTION(DDTrace_flush) {
     if (get_DD_AUTOFINISH_SPANS()) {
         ddtrace_close_userland_spans_until(NULL);
     }
-    if (ddtrace_flush_tracer(false, get_DD_TRACE_FLUSH_COLLECT_CYCLES()) == FAILURE) {
+    if (ddtrace_flush_tracer(false, get_DD_TRACE_FLUSH_COLLECT_CYCLES(), false) == FAILURE) {
         LOG_LINE(WARN, "Unable to flush the tracer");
     }
     RETURN_NULL();
diff --git a/ext/ddtrace.h b/ext/ddtrace.h
@@ -71,7 +71,7 @@ bool ddtrace_alter_default_propagation_style(zval *old_value, zval *new_value, z
 bool ddtrace_alter_dd_service(zval *old_value, zval *new_value, zend_string *new_str);
 bool ddtrace_alter_dd_env(zval *old_value, zval *new_value, zend_string *new_str);
 bool ddtrace_alter_dd_version(zval *old_value, zval *new_value, zend_string *new_str);
-void dd_force_shutdown_tracing(void);
+void dd_force_shutdown_tracing(bool fast_shutdown);
 void dd_internal_handle_fork(void);
 #ifdef CXA_THREAD_ATEXIT_WRAPPER
 void dd_run_rust_thread_destructors(void *unused);
diff --git a/ext/handlers_exception.c b/ext/handlers_exception.c
@@ -380,7 +380,7 @@ void dd_exception_handler_freed(zend_object *object) {
         // Here we are at the very last chance before objects are unconditionally freed.
         // Let's force-disable the tracing in case it wasn't yet
         // Typically RSHUTDOWN would handle that, but since 8.1.0 opcache will free our objects before module_shutdown during preloading
-        dd_force_shutdown_tracing();
+        dd_force_shutdown_tracing(false);
     }
 }
 #endif
diff --git a/ext/span.c b/ext/span.c
@@ -836,7 +836,7 @@ static void dd_close_entry_span_of_stack(ddtrace_span_stack *stack) {
             ddtrace_switch_span_stack(stack->parent_stack);
         }
 
-        if (get_DD_TRACE_AUTO_FLUSH_ENABLED() && ddtrace_flush_tracer(false, get_DD_TRACE_FLUSH_COLLECT_CYCLES()) == FAILURE) {
+        if (get_DD_TRACE_AUTO_FLUSH_ENABLED() && ddtrace_flush_tracer(false, get_DD_TRACE_FLUSH_COLLECT_CYCLES(), false) == FAILURE) {
             // In case we have root spans enabled, we need to always flush if we close that one (RSHUTDOWN)
             LOG(WARN, "Unable to auto flush the tracer");
         }
@@ -1080,7 +1080,7 @@ void ddtrace_drop_span(ddtrace_span_data *span) {
     dd_drop_span(span, false);
 }
 
-void ddtrace_serialize_closed_spans(ddog_TracesBytes *traces) {
+void ddtrace_serialize_closed_spans(ddog_TracesBytes *traces, bool fast_shutdown) {
     if (DDTRACE_G(top_closed_stack)) {
         ddtrace_span_stack *rootstack = DDTRACE_G(top_closed_stack);
         DDTRACE_G(top_closed_stack) = NULL;
@@ -1108,7 +1108,9 @@ void ddtrace_serialize_closed_spans(ddog_TracesBytes *traces) {
                     // remove the artificially increased RC while closing again
                     GC_SET_REFCOUNT(&tmp->std, GC_REFCOUNT(&tmp->std) - DD_RC_CLOSED_MARKER);
 #endif
-                    OBJ_RELEASE(&tmp->std);
+                    if (!fast_shutdown) {
+                        OBJ_RELEASE(&tmp->std);
+                    }
                 } while (span != end);
                 // We hold a reference to stacks with flushable spans
                 OBJ_RELEASE(&stack->std);
@@ -1128,10 +1130,10 @@ void ddtrace_serialize_closed_spans(ddog_TracesBytes *traces) {
     DDTRACE_G(dropped_spans_count) = 0;
 }
 
-void ddtrace_serialize_closed_spans_with_cycle(ddog_TracesBytes *traces) {
+void ddtrace_serialize_closed_spans_with_cycle(ddog_TracesBytes *traces, bool fast_shutdown) {
     // We need to loop here, as closing the last span root stack could add other spans here
     while (DDTRACE_G(top_closed_stack)) {
-        ddtrace_serialize_closed_spans(traces);
+        ddtrace_serialize_closed_spans(traces, fast_shutdown);
         if (DDTRACE_G(open_spans_count)) {
             // Also flush possible cycles here, if there are remaining open spans
             gc_collect_cycles();
diff --git a/ext/span.h b/ext/span.h
@@ -259,8 +259,8 @@ void ddtrace_close_top_span_without_stack_swap(ddtrace_span_data *span);
 void ddtrace_close_all_open_spans(bool force_close_root_span);
 void ddtrace_drop_span(ddtrace_span_data *span);
 void ddtrace_mark_all_span_stacks_flushable(void);
-void ddtrace_serialize_closed_spans(ddog_TracesBytes *traces);
-void ddtrace_serialize_closed_spans_with_cycle(ddog_TracesBytes *traces);
+void ddtrace_serialize_closed_spans(ddog_TracesBytes *traces, bool fast_shutdown);
+void ddtrace_serialize_closed_spans_with_cycle(ddog_TracesBytes *traces, bool fast_shutdown);
 zend_string *ddtrace_span_id_as_string(uint64_t id);
 zend_string *ddtrace_trace_id_as_string(ddtrace_trace_id id);
 zend_string *ddtrace_span_id_as_hex_string(uint64_t id);
diff --git a/zend_abstract_interface/hook/hook.c b/zend_abstract_interface/hook/hook.c
@@ -1178,12 +1178,16 @@ bool zai_hook_ginit(void) {
     return true;
 }
 
-bool zai_hook_rinit(void) {
+static void zai_hook_init_hashtables() {
     zend_hash_init(&zai_hook_tls->inheritors, 8, NULL, zai_hook_inheritors_destroy, 0);
     zend_hash_init(&zai_hook_tls->request_files.hooks, 8, NULL, zai_hook_destroy, 0);
     zend_hash_init(&zai_hook_tls->request_functions, 8, NULL, zai_hook_hash_destroy, 0);
     zend_hash_init(&zai_hook_tls->request_classes, 8, NULL, zai_hook_hash_destroy, 0);
     zend_hash_init(&zai_hook_resolved, 8, NULL, NULL, 0);
+}
+
+bool zai_hook_rinit(void) {
+    zai_hook_init_hashtables();
     zend_hash_init(&zai_function_location_map, 8, NULL, zai_function_location_destroy, 0);
 
     // reserve low hook ids for static hooks
@@ -1488,17 +1492,21 @@ bool zai_hook_remove(zai_str scope, zai_str function, zend_long index) {
     return false;
 }
 
-void zai_hook_clean(void) {
-    // graceful clean: ensure that destructors executing during cleanup may still access zai_hook_resolved
-    zend_hash_apply(&zai_hook_resolved, zai_hook_clean_graceful_del);
-    zend_hash_clean(&zai_hook_tls->request_functions);
-    zend_hash_clean(&zai_hook_tls->request_classes);
+void zai_hook_clean(bool fast_shutdown) {
+    if (fast_shutdown) {
+        // We just reinitialize the hashtables to empty, so that no other hooks are executed.
+        // In the possible case where more code gets executed after - that's fine; the actual destroy comes later.
+        zai_hook_init_hashtables();
+    } else {
+        // graceful clean: ensure that destructors executing during cleanup may still access zai_hook_resolved
+        zend_hash_apply(&zai_hook_resolved, zai_hook_clean_graceful_del);
+        zend_hash_clean(&zai_hook_tls->request_functions);
+        zend_hash_clean(&zai_hook_tls->request_classes);
 
-    zend_hash_iterators_remove(&zai_hook_tls->request_files.hooks);
-    zend_hash_clean(&zai_hook_tls->request_files.hooks);
+        zend_hash_iterators_remove(&zai_hook_tls->request_files.hooks);
+        zend_hash_clean(&zai_hook_tls->request_files.hooks);
+    }
     zai_hook_tls->request_files.dynamic = 0;
-
-    zend_hash_clean(&zai_function_location_map);
 }
 
 static void zai_hook_iterator_set_current_and_advance(zai_hook_iterator *it) {
diff --git a/zend_abstract_interface/hook/hook.h b/zend_abstract_interface/hook/hook.h
@@ -14,7 +14,7 @@ bool zai_hook_ginit(void);
 bool zai_hook_rinit(void);
 void zai_hook_post_startup(void);
 void zai_hook_activate(void);
-void zai_hook_clean(void);
+void zai_hook_clean(bool fast_shutdown);
 void zai_hook_rshutdown(void);
 void zai_hook_gshutdown(void);
 void zai_hook_mshutdown(void); /* }}} */

Original file line number	Diff line number	Diff line change
`@@ -380,7 +380,7 @@ void dd_exception_handler_freed(zend_object *object) {`
`380`	`380`	`// Here we are at the very last chance before objects are unconditionally freed.`
`381`	`381`	`// Let's force-disable the tracing in case it wasn't yet`
`382`	`382`	`// Typically RSHUTDOWN would handle that, but since 8.1.0 opcache will free our objects before module_shutdown during preloading`
`383`		`- dd_force_shutdown_tracing();`
	`383`	`+ dd_force_shutdown_tracing(false);`
`384`	`384`	`}`
`385`	`385`	`}`
`386`	`386`	`#endif`