From 361b1909e43939507d1db2e092623e472e2cb25f Mon Sep 17 00:00:00 2001
From: Pawel Filipczak <pawel.filipczak@elastic.co>
Date: Mon, 3 Feb 2025 14:12:14 +0100
Subject: [PATCH] Inferred spans (#152)

---
 docs/configure.md                             |  28 +-
 prod/native/CMakeLists.txt                    |   3 -
 prod/native/extension/code/Hooking.cpp        |  41 +-
 prod/native/extension/code/Hooking.h          |  24 +-
 prod/native/extension/code/ModuleEntry.cpp    |  14 +-
 .../native/extension/code/ModuleFunctions.cpp |  22 +
 .../extension/code/ModuleIniEntries.cpp       |   6 +
 prod/native/extension/code/ModuleInit.cpp     |   7 +-
 prod/native/libcommon/code/AgentGlobals.cpp   |  30 +-
 prod/native/libcommon/code/AgentGlobals.h     |   7 +-
 .../libcommon/code/ConfigurationManager.h     |   7 +-
 .../libcommon/code/ConfigurationSnapshot.h    |  12 +
 prod/native/libcommon/code/InferredSpans.h    |  96 ++++
 .../libcommon/code/PeriodicTaskExecutor.h     |   6 +-
 prod/native/libcommon/code/RequestScope.h     |  29 +-
 .../test/PeriodicTaskExecutorTest.cpp         |  10 +-
 prod/native/libphpbridge/code/PhpBridge.cpp   |  56 +--
 prod/native/libphpbridge/code/PhpBridge.h     |   2 +-
 .../InferredSpans/InferredSpans.php           | 411 ++++++++++++++++++
 prod/php/ElasticOTel/PhpPartFacade.php        |  37 +-
 20 files changed, 799 insertions(+), 49 deletions(-)
 create mode 100644 prod/native/libcommon/code/InferredSpans.h
 create mode 100644 prod/php/ElasticOTel/InferredSpans/InferredSpans.php

diff --git a/docs/configure.md b/docs/configure.md
index a9dc85b..29722d4 100644
--- a/docs/configure.md
+++ b/docs/configure.md
@@ -55,20 +55,46 @@ _Currently there are no additional `OTEL_` options waiting to be contributed ups
 
 `ELASTIC_OTEL_` options that are specific to Elastic and will always live in EDOT PHP (in other words, they will _not_ be added upstream):
 
+#### General configuration ####
 
 | Option(s) | Default | Accepted values | Description |
 |---|---|---|---|
 |ELASTIC_OTEL_ENABLED|true|true or false|Enables the automatic bootstrapping of instrumentation code|
+
+#### Asynchronous data sending configuration ####
+
+| Option(s) | Default | Accepted values | Description |
+|---|---|---|---|
 |ELASTIC_OTEL_ASYNC_TRANSPORT|true| true or false | Use asynchronous (background) transfer of traces, metrics and logs. If false - brings back original OpenTelemetry SDK transfer modes|
-|ELASTIC_OTEL_ASYNC_TRANSPORT_SHUTDOWN_TIMEOUT| 30s | interger numberwith time duration. Set to 0 to disable the timeout. Optional units: ms (default), s, m | Timeout after which the asynchronous (background) transfer will interrupt data transmission during process termination|
+|ELASTIC_OTEL_ASYNC_TRANSPORT_SHUTDOWN_TIMEOUT| 30s | interger number with time duration. Set to 0 to disable the timeout. Optional units: ms (default), s, m | Timeout after which the asynchronous (background) transfer will interrupt data transmission during process termination|
 |ELASTIC_OTEL_MAX_SEND_QUEUE_SIZE|2MB| integer number with optional units: B, MB or GB | Set the maximum buffer size for asynchronous (background) transfer. It is set per worker process.|
 |ELASTIC_OTEL_VERIFY_SERVER_CERT|true|true or false|Enables server certificate verification for asynchronous sending|
+
+#### Logging configuration ####
+
+| Option(s) | Default | Accepted values | Description |
+|---|---|---|---|
 |ELASTIC_OTEL_LOG_FILE||Filesystem path|Log file name. You can use the %p placeholder where the process ID will appear in the file name, and %t where the timestamp will appear. Please note that the PHP process must have write permissions for the specified path.|
 |ELASTIC_OTEL_LOG_LEVEL_FILE|OFF|OFF, CRITICAL, ERROR, WARNING, INFO, DEBUG, TRACE|Log level for file sink. Set to OFF if you don't want to log to file.
 |ELASTIC_OTEL_LOG_LEVEL_STDERR|OFF|OFF, CRITICAL, ERROR, WARNING, INFO, DEBUG, TRACE|Log level for the stderr sink. Set to OFF if you don't want to log to a file. This sink is recommended when running the application in a container.
 |ELASTIC_OTEL_LOG_LEVEL_SYSLOG|OFF|OFF, CRITICAL, ERROR, WARNING, INFO, DEBUG, TRACE|Log level for file sink. Set to OFF if you don't want to log to file. This sink is recommended when you don't have write access to file system.
 |ELASTIC_OTEL_LOG_FEATURES||Comma separated string with FEATURE=LEVEL pairs.<br>Supported features:<br>ALL, MODULE, REQUEST, TRANSPORT, BOOTSTRAP, HOOKS, INSTRUMENTATION|Allows selective setting of log level for features. For example, "ALL=info,TRANSPORT=trace" will result in all other features logging at the info level, while the TRANSPORT feature logs at the trace level. It should be noted that the appropriate log level must be set for the sink - for our example, this would be TRACE.
+
+#### Transaction span configuration ####
+
+| Option(s) | Default | Accepted values | Description |
+|---|---|---|---|
 |ELASTIC_OTEL_TRANSACTION_SPAN_ENABLED|true|true or false|Enables automatic creation of transaction (root) spans for the webserver SAPI. The name of the span will correspond to the request method and path.|
 |ELASTIC_OTEL_TRANSACTION_SPAN_ENABLED_CLI|true|true or false|Enables automatic creation of transaction (root) spans for the CLI SAPI. The name of the span will correspond to the script name.|
 |ELASTIC_OTEL_TRANSACTION_URL_GROUPS||Comma-separated list of wildcard expressions|Allows grouping multiple URL paths using wildcard expressions, such as `/user/*`. For example, `/user/Alice` and `/user/Bob` will be mapped to the transaction name `/user/*`.|
 | <option> | <default value> | <description> |
+
+#### Inferred spans configuration ####
+
+| Option(s) | Default | Accepted values | Description |
+|---|---|---|---|
+|ELASTIC_OTEL_INFERRED_SPANS_ENABLED|false|true or false|Enables the inferred spans feature.|
+|ELASTIC_OTEL_INFERRED_SPANS_REDUCTION_ENABLED|true|true or false|If enabled, reduces the number of spans by eliminating preceding frames with the same execution time.|
+|ELASTIC_OTEL_INFERRED_SPANS_STACKTRACE_ENABLED|true|true or false|If enabled, attaches a stack trace to the span metadata.|
+|ELASTIC_OTEL_INFERRED_SPANS_SAMPLING_INTERVAL|50ms|interger number with time duration. Optional units: ms (default), s, m. It can't be set to 0.|The frequency at which stack traces are gathered within a profiling session. The lower you set it, the more accurate the durations will be. This comes at the expense of higher overhead and more spans for potentially irrelevant operations. The minimal duration of a profiling-inferred span is the same as the value of this setting.|
+|ELASTIC_OTEL_INFERRED_SPANS_MIN_DURATION|0|interger number with time duration. Optional units: ms (default), s, m. _Disabled if set to 0_.|The minimum duration of an inferred span. Note that the min duration is also implicitly set by the sampling interval. However, increasing the sampling interval also decreases the accuracy of the duration of inferred spans.|
\ No newline at end of file
diff --git a/prod/native/CMakeLists.txt b/prod/native/CMakeLists.txt
index fe09b88..0b3154a 100644
--- a/prod/native/CMakeLists.txt
+++ b/prod/native/CMakeLists.txt
@@ -1,8 +1,5 @@
 cmake_minimum_required(VERSION 3.26.0)
 
-
-#TODO paplo tutaj jakos zgrac te sciezki ze skryptami i tyle
-
 # set path for our local includes
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/building/cmake")
 list(APPEND CMAKE_PREFIX_PATH "${CMAKE_BINARY_DIR}/build/${CMAKE_BUILD_TYPE}/generators")
diff --git a/prod/native/extension/code/Hooking.cpp b/prod/native/extension/code/Hooking.cpp
index 2a4f41f..4e6d998 100644
--- a/prod/native/extension/code/Hooking.cpp
+++ b/prod/native/extension/code/Hooking.cpp
@@ -29,6 +29,7 @@
 #include "InternalFunctionInstrumentation.h"
 #include "PeriodicTaskExecutor.h"
 #include "RequestScope.h"
+#include "InferredSpans.h"
 #include "os/OsUtils.h"
 
 #include <main/php_version.h>
@@ -79,8 +80,46 @@ void elastic_observer_error_cb(int type, zend_string *error_filename, uint32_t e
     errorHandling = false;
 }
 
-void Hooking::replaceHooks() {
+static void elastic_interrupt_function(zend_execute_data *execute_data) {
+    ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "%s: interrupt", __FUNCTION__);
+
+    ELASTICAPM_G(globals)->inferredSpans_->attachBacktraceIfInterrupted();
+
+    zend_try {
+        if (Hooking::getInstance().getOriginalZendInterruptFunction()) {
+            Hooking::getInstance().getOriginalZendInterruptFunction()(execute_data);
+        }
+    }
+    zend_catch {
+        ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "%s: original call error", __FUNCTION__);
+    }
+    zend_end_try();
+}
+
+static void elastic_execute_internal(INTERNAL_FUNCTION_PARAMETERS) {
+    zend_try {
+        if (Hooking::getInstance().getOriginalExecuteInternal()) {
+            Hooking::getInstance().getOriginalExecuteInternal()(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+        } else {
+            execute_internal(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+        }
+    }
+    zend_catch {
+        ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "%s: original call error", __FUNCTION__);
+    }
+    zend_end_try();
+
+    ELASTICAPM_G(globals)->inferredSpans_->attachBacktraceIfInterrupted();
+}
+
+void Hooking::replaceHooks(bool enableInferredSpansHooks) {
     zend_observer_error_register(elastic_observer_error_cb);
+
+    if (enableInferredSpansHooks) {
+        ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "Hooked into zend_execute_internal and zend_interrupt_function");
+        zend_execute_internal = elastic_execute_internal;
+        zend_interrupt_function = elastic_interrupt_function;
+    }
 }
 
 } // namespace elasticapm::php
diff --git a/prod/native/extension/code/Hooking.h b/prod/native/extension/code/Hooking.h
index a69139d..62b17df 100644
--- a/prod/native/extension/code/Hooking.h
+++ b/prod/native/extension/code/Hooking.h
@@ -19,26 +19,48 @@
 
 #pragma once
 
+#include <Zend/zend_execute.h>
+#include <Zend/zend_types.h>
+
 namespace elasticapm::php {
 
 class Hooking {
 public:
+    using zend_execute_internal_t = void (*)(zend_execute_data *execute_data, zval *return_value);
+    using zend_interrupt_function_t = void (*)(zend_execute_data *execute_data);
+
     static Hooking &getInstance() {
         static Hooking instance;
         return instance;
     }
 
     void fetchOriginalHooks() {
+        original_execute_internal_ = zend_execute_internal;
+        original_zend_interrupt_function_ = zend_interrupt_function;
     }
 
     void restoreOriginalHooks() {
+        zend_execute_internal = original_execute_internal_;
+        zend_interrupt_function = original_zend_interrupt_function_;
+    }
+
+    zend_execute_internal_t getOriginalExecuteInternal() {
+        return original_execute_internal_;
     }
 
-    void replaceHooks();
+    zend_interrupt_function_t getOriginalZendInterruptFunction() {
+        return original_zend_interrupt_function_;
+    }
+
+    void replaceHooks(bool enableInferredSpansHooks);
+
 private:
     Hooking(Hooking const &) = delete;
     void operator=(Hooking const &) = delete;
     Hooking() = default;
+
+    zend_execute_internal_t original_execute_internal_ = nullptr;
+    zend_interrupt_function_t original_zend_interrupt_function_ = nullptr;
 };
 
 } // namespace elasticapm::php
\ No newline at end of file
diff --git a/prod/native/extension/code/ModuleEntry.cpp b/prod/native/extension/code/ModuleEntry.cpp
index d1e7f35..847fcb7 100644
--- a/prod/native/extension/code/ModuleEntry.cpp
+++ b/prod/native/extension/code/ModuleEntry.cpp
@@ -33,6 +33,7 @@
 #include "os/OsUtils.h"
 #include "CallOnScopeExit.h"
 #include "ConfigurationManager.h"
+#include "InferredSpans.h"
 #include "InstrumentedFunctionHooksStorage.h"
 #include "InternalFunctionInstrumentation.h"
 #include "Logger.h"
@@ -45,7 +46,6 @@
 #include "SharedMemoryState.h"
 
 
-
 ZEND_DECLARE_MODULE_GLOBALS( elastic_otel )
 
 elasticapm::php::ConfigurationManager configManager([](std::string_view iniName) -> std::optional<std::string> {
@@ -102,8 +102,18 @@ static PHP_GINIT_FUNCTION(elastic_otel) {
 
     auto hooksStorage = std::make_shared<elasticapm::php::InstrumentedFunctionHooksStorage_t>();
 
+    auto inferredSpans = std::make_shared<elasticapm::php::InferredSpans>([interruptFlag = reinterpret_cast<void *>(&EG(vm_interrupt))]() {
+#if PHP_VERSION_ID >= 80200
+        zend_atomic_bool_store_ex(reinterpret_cast<zend_atomic_bool *>(interruptFlag), true);
+#else
+        *static_cast<zend_bool *>(interruptFlag) = 1;
+#endif
+    }, [phpBridge](elasticapm::php::InferredSpans::time_point_t requestTime, elasticapm::php::InferredSpans::time_point_t now) {
+        phpBridge->callInferredSpans(now - requestTime);
+    });
+
     try {
-        elastic_otel_globals->globals = new elasticapm::php::AgentGlobals(logger, std::move(logSinkStdErr), std::move(logSinkSysLog), std::move(logSinkFile), std::move(phpBridge), std::move(hooksStorage), [](elasticapm::php::ConfigurationSnapshot &cfg) { return configManager.updateIfChanged(cfg); });
+        elastic_otel_globals->globals = new elasticapm::php::AgentGlobals(logger, std::move(logSinkStdErr), std::move(logSinkSysLog), std::move(logSinkFile), std::move(phpBridge), std::move(hooksStorage), std::move(inferredSpans), [](elasticapm::php::ConfigurationSnapshot &cfg) { return configManager.updateIfChanged(cfg); });
     } catch (std::exception const &e) {
         ELOGF_CRITICAL(logger, MODULE, "Unable to allocate AgentGlobals. '%s'", e.what());
     }
diff --git a/prod/native/extension/code/ModuleFunctions.cpp b/prod/native/extension/code/ModuleFunctions.cpp
index 87cfe1d..865785f 100644
--- a/prod/native/extension/code/ModuleFunctions.cpp
+++ b/prod/native/extension/code/ModuleFunctions.cpp
@@ -26,6 +26,7 @@
 #include "ModuleFunctionsImpl.h"
 #include "InternalFunctionInstrumentation.h"
 #include "transport/HttpTransportAsync.h"
+#include "PhpBridge.h"
 
 #include <main/php.h>
 #include <Zend/zend_API.h>
@@ -274,6 +275,26 @@ PHP_FUNCTION(enqueue) {
     EAPM_GL(httpTransportAsync_)->enqueue(ZSTR_HASH(endpoint), std::span<std::byte>(reinterpret_cast<std::byte *>(ZSTR_VAL(payload)), ZSTR_LEN(payload)));
 }
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(elastic_otel_force_set_object_propety_value_arginfo, 0, 3, _IS_BOOL, 0)
+ZEND_ARG_TYPE_INFO(0, object, IS_OBJECT, 0)
+ZEND_ARG_TYPE_INFO(0, property_name, IS_STRING, 0)
+ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+PHP_FUNCTION(force_set_object_propety_value) {
+    zend_object *object = nullptr;
+    zend_string *property_name = nullptr;
+    zval *value = nullptr;
+
+    ZEND_PARSE_PARAMETERS_START(3, 3)
+    Z_PARAM_OBJ(object)
+    Z_PARAM_STR(property_name)
+    Z_PARAM_ZVAL(value)
+    ZEND_PARSE_PARAMETERS_END();
+
+    RETURN_BOOL(elasticapm::php::forceSetObjectPropertyValue(object, property_name, value));
+}
+
 // clang-format off
 const zend_function_entry elastic_otel_functions[] = {
     PHP_FE( elastic_otel_is_enabled, elastic_otel_no_paramters_arginfo )
@@ -286,6 +307,7 @@ const zend_function_entry elastic_otel_functions[] = {
 
     ZEND_NS_FE( "Elastic\\Otel\\HttpTransport", initialize, ArgInfoInitialize)
     ZEND_NS_FE( "Elastic\\Otel\\HttpTransport", enqueue, elastic_otel_no_paramters_arginfo)
+    ZEND_NS_FE( "Elastic\\Otel\\InferredSpans", force_set_object_propety_value, elastic_otel_force_set_object_propety_value_arginfo)
 
     PHP_FE_END
 };
diff --git a/prod/native/extension/code/ModuleIniEntries.cpp b/prod/native/extension/code/ModuleIniEntries.cpp
index 9a9797a..7d7acf8 100644
--- a/prod/native/extension/code/ModuleIniEntries.cpp
+++ b/prod/native/extension/code/ModuleIniEntries.cpp
@@ -67,6 +67,12 @@ ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_MAX_SEND_QUEUE_SIZ
 ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_ASYNC_TRANSPORT))
 ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_INSTRUMENT_ALL))
 ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_PHP_HOOKS_ENABLED))
+
+ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_ENABLED))
+ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_REDUCTION_ENABLED))
+ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_STACKTRACE_ENABLED))
+ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_SAMPLING_INTERVAL))
+ELASTIC_OTEL_INI_ENTRY(EL_STRINGIFY(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_MIN_DURATION))
 PHP_INI_END()
 
 namespace elasticapm::php {
diff --git a/prod/native/extension/code/ModuleInit.cpp b/prod/native/extension/code/ModuleInit.cpp
index 723054b..15778ad 100644
--- a/prod/native/extension/code/ModuleInit.cpp
+++ b/prod/native/extension/code/ModuleInit.cpp
@@ -76,10 +76,6 @@ void elasticApmModuleInit(int moduleType, int moduleNumber) {
 
     registerSigSegvHandler(globals->logger_.get());
 
-    elasticapm::php::Hooking::getInstance().fetchOriginalHooks();
-
-    // CURLcode curlCode;
-
     logStartupPreamble(globals->logger_.get());
 
     if (!EAPM_CFG(enabled)) {
@@ -88,7 +84,8 @@ void elasticApmModuleInit(int moduleType, int moduleNumber) {
     }
 
     ELOGF_DEBUG(globals->logger_, MODULE, "MINIT Replacing hooks");
-    elasticapm::php::Hooking::getInstance().replaceHooks();
+    elasticapm::php::Hooking::getInstance().fetchOriginalHooks();
+    elasticapm::php::Hooking::getInstance().replaceHooks(globals->config_->get().inferred_spans_enabled);
 
     zend_observer_activate();
     zend_observer_fcall_register(elasticapm::php::elasticRegisterObserver);
diff --git a/prod/native/libcommon/code/AgentGlobals.cpp b/prod/native/libcommon/code/AgentGlobals.cpp
index 4377363..db32361 100644
--- a/prod/native/libcommon/code/AgentGlobals.cpp
+++ b/prod/native/libcommon/code/AgentGlobals.cpp
@@ -21,6 +21,8 @@
 
 #include "PhpBridgeInterface.h"
 #include "SharedMemoryState.h"
+#include "InferredSpans.h"
+#include "PeriodicTaskExecutor.h"
 #include "PeriodicTaskExecutor.h"
 #include "RequestScope.h"
 #include "LoggerInterface.h"
@@ -31,6 +33,7 @@
 #include "transport/HttpTransportAsync.h"
 
 #include "LogFeature.h"
+#include <signal.h>
 
 namespace elasticapm::php {
 // clang-format off
@@ -41,16 +44,18 @@ AgentGlobals::AgentGlobals(std::shared_ptr<LoggerInterface> logger,
         std::shared_ptr<LoggerSinkFile> logSinkFile,
         std::shared_ptr<PhpBridgeInterface> bridge,
         std::shared_ptr<InstrumentedFunctionHooksStorageInterface> hooksStorage,
+        std::shared_ptr<InferredSpans> inferredSpans,
         ConfigurationStorage::configUpdate_t updateConfigurationSnapshot) :
     config_(std::make_shared<elasticapm::php::ConfigurationStorage>(std::move(updateConfigurationSnapshot))),
     logger_(std::move(logger)),
     bridge_(std::move(bridge)),
     hooksStorage_(std::move(hooksStorage)),
     sapi_(std::make_shared<elasticapm::php::PhpSapi>(bridge_->getPhpSapiName())),
+    inferredSpans_(std::move(inferredSpans)),
     periodicTaskExecutor_(),
     httpTransportAsync_(std::make_unique<elasticapm::php::transport::HttpTransportAsync<>>(logger_, config_)),
     sharedMemory_(std::make_shared<elasticapm::php::SharedMemoryState>()),
-    requestScope_(std::make_shared<elasticapm::php::RequestScope>(logger_, bridge_, sapi_, sharedMemory_, config_, [hs = hooksStorage_]() { hs->clear(); })),
+    requestScope_(std::make_shared<elasticapm::php::RequestScope>(logger_, bridge_, sapi_, sharedMemory_, inferredSpans_, config_, [hs = hooksStorage_]() { hs->clear(); }, [this]() { return getPeriodicTaskExecutor();})),
     logSinkStdErr_(std::move(logSinkStdErr)),
     logSinkSysLog_(std::move(logSinkSysLog)),
     logSinkFile_(std::move(logSinkFile))
@@ -76,6 +81,29 @@ AgentGlobals::~AgentGlobals() {
     config_->removeAllConfigUpdateWatchers();
 }
 
+std::shared_ptr<PeriodicTaskExecutor> AgentGlobals::getPeriodicTaskExecutor() {
+    if (periodicTaskExecutor_) {
+        return periodicTaskExecutor_;
+    }
+
+    periodicTaskExecutor_ = std::make_shared<elasticapm::php::PeriodicTaskExecutor>(
+            std::vector<elasticapm::php::PeriodicTaskExecutor::task_t>{
+            [inferredSpans = inferredSpans_](elasticapm::php::PeriodicTaskExecutor::time_point_t now) { inferredSpans->tryRequestInterrupt(now); }
+            },
+            []() {
+                // block signals for this thread to be handled by main Apache/PHP thread
+                // list of signals from Apaches mpm handlers
+                elasticapm::utils::blockSignal(SIGTERM);
+                elasticapm::utils::blockSignal(SIGHUP);
+                elasticapm::utils::blockSignal(SIGINT);
+                elasticapm::utils::blockSignal(SIGWINCH);
+                elasticapm::utils::blockSignal(SIGUSR1);
+                elasticapm::utils::blockSignal(SIGPROF); // php timeout signal
+            }
+        );
+        return periodicTaskExecutor_;
+    }
+
 
 }
 
diff --git a/prod/native/libcommon/code/AgentGlobals.h b/prod/native/libcommon/code/AgentGlobals.h
index dbfa428..4eca478 100644
--- a/prod/native/libcommon/code/AgentGlobals.h
+++ b/prod/native/libcommon/code/AgentGlobals.h
@@ -28,6 +28,7 @@ namespace elasticapm::php {
 
 class LoggerInterface;
 class PhpBridgeInterface;
+class InferredSpans;
 class PeriodicTaskExecutor;
 class SharedMemoryState;
 class RequestScope;
@@ -53,16 +54,20 @@ class AgentGlobals {
         std::shared_ptr<LoggerSinkFile> logSinkFile,
         std::shared_ptr<PhpBridgeInterface> bridge,
         std::shared_ptr<InstrumentedFunctionHooksStorageInterface> hooksStorage,
+        std::shared_ptr<InferredSpans> inferredSpans,
         std::function<bool(ConfigurationSnapshot &)> updateConfigurationSnapshot);
 
     ~AgentGlobals();
 
+    std::shared_ptr<PeriodicTaskExecutor> getPeriodicTaskExecutor();
+
     std::shared_ptr<ConfigurationStorage> config_;
     std::shared_ptr<LoggerInterface> logger_;
     std::shared_ptr<PhpBridgeInterface> bridge_;
     std::shared_ptr<InstrumentedFunctionHooksStorageInterface> hooksStorage_;
     std::shared_ptr<PhpSapi> sapi_;
-    std::unique_ptr<PeriodicTaskExecutor> periodicTaskExecutor_;
+    std::shared_ptr<InferredSpans> inferredSpans_;
+    std::shared_ptr<PeriodicTaskExecutor> periodicTaskExecutor_;
     std::unique_ptr<transport::HttpTransportAsync<transport::CurlSender, transport::HttpEndpoints> > httpTransportAsync_;
     std::shared_ptr<SharedMemoryState> sharedMemory_;
     std::shared_ptr<RequestScope> requestScope_;
diff --git a/prod/native/libcommon/code/ConfigurationManager.h b/prod/native/libcommon/code/ConfigurationManager.h
index 8fe8f57..0580826 100644
--- a/prod/native/libcommon/code/ConfigurationManager.h
+++ b/prod/native/libcommon/code/ConfigurationManager.h
@@ -113,7 +113,12 @@ class ConfigurationManager {
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_ASYNC_TRANSPORT, OptionMetadata::type::boolean, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_ASYNC_TRANSPORT_SHUTDOWN_TIMEOUT, OptionMetadata::type::duration, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_INSTRUMENT_ALL, OptionMetadata::type::boolean, false),
-        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_PHP_HOOKS_ENABLED, OptionMetadata::type::boolean, false)};
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_PHP_HOOKS_ENABLED, OptionMetadata::type::boolean, false),
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_ENABLED, OptionMetadata::type::boolean, false),
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_REDUCTION_ENABLED, OptionMetadata::type::boolean, false),
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_STACKTRACE_ENABLED, OptionMetadata::type::boolean, false),
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_SAMPLING_INTERVAL, OptionMetadata::type::duration, false),
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_MIN_DURATION, OptionMetadata::type::duration, false)};
 
     // clang-format on
 };
diff --git a/prod/native/libcommon/code/ConfigurationSnapshot.h b/prod/native/libcommon/code/ConfigurationSnapshot.h
index 44b2282..e4e203a 100644
--- a/prod/native/libcommon/code/ConfigurationSnapshot.h
+++ b/prod/native/libcommon/code/ConfigurationSnapshot.h
@@ -41,6 +41,12 @@
 #define ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_INSTRUMENT_ALL debug_instrument_all
 #define ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_PHP_HOOKS_ENABLED debug_php_hooks_enabled
 
+#define ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_ENABLED inferred_spans_enabled
+#define ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_REDUCTION_ENABLED inferred_spans_reduction_enabled
+#define ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_STACKTRACE_ENABLED inferred_spans_stacktrace_enabled
+#define ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_SAMPLING_INTERVAL inferred_spans_sampling_interval
+#define ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_MIN_DURATION inferred_spans_min_duration
+
 namespace elasticapm::php {
 
 using namespace std::string_literals;
@@ -62,6 +68,12 @@ struct ConfigurationSnapshot {
     bool ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_INSTRUMENT_ALL = false;
     bool ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_PHP_HOOKS_ENABLED = false;
 
+    bool ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_ENABLED = false;
+    bool ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_REDUCTION_ENABLED = true;
+    bool ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_STACKTRACE_ENABLED = true;
+    std::chrono::milliseconds ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_SAMPLING_INTERVAL = std::chrono::milliseconds(50);
+    std::chrono::milliseconds ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_MIN_DURATION = std::chrono::milliseconds(0);
+
     uint64_t revision = 0;
 };
 
diff --git a/prod/native/libcommon/code/InferredSpans.h b/prod/native/libcommon/code/InferredSpans.h
new file mode 100644
index 0000000..58cb582
--- /dev/null
+++ b/prod/native/libcommon/code/InferredSpans.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <unistd.h>
+namespace elasticapm::php {
+
+class InferredSpans {
+public:
+    using clock_t = std::chrono::steady_clock;
+    using time_point_t = std::chrono::time_point<clock_t, std::chrono::milliseconds>;
+    using interruptFunc_t = std::function<void()>;
+    using attachInferredSpansOnPhp_t = std::function<void(time_point_t interruptRequest, time_point_t now)>;
+
+    InferredSpans(interruptFunc_t interrupt, attachInferredSpansOnPhp_t attachInferredSpansOnPhp) : interrupt_(interrupt), attachInferredSpansOnPhp_(attachInferredSpansOnPhp) {
+    }
+
+    void attachBacktraceIfInterrupted() {
+        if (phpSideBacktracePending_.load()) { // avoid triggers from agent side with low interval
+            return;
+        }
+
+        std::unique_lock lock(mutex_);
+        time_point_t requestInterruptTime = lastInterruptRequestTick_;
+
+        if (checkAndResetInterruptFlag()) {
+            phpSideBacktracePending_ = true;
+            lock.unlock();
+            attachInferredSpansOnPhp_(requestInterruptTime, std::chrono::time_point_cast<std::chrono::milliseconds>(clock_t::now()));
+            phpSideBacktracePending_ = false;
+        }
+    }
+
+    void tryRequestInterrupt(time_point_t now) {
+        if (interruptedRequested_.load()) {
+            return; // it was requested to interrupt in previous interval
+        }
+
+        std::unique_lock lock(mutex_);
+
+        if (now > lastInterruptRequestTick_ + samplingInterval_) {
+            lastInterruptRequestTick_ = now;
+
+            interruptedRequested_ = true;
+            lock.unlock();
+            interrupt_(); // set interrupt for user space functions
+        }
+    }
+
+    void setInterval(std::chrono::milliseconds interval) {
+        std::lock_guard lock(mutex_);
+        samplingInterval_ = interval;
+    }
+
+    void reset() {
+        std::lock_guard lock(mutex_);
+        lastInterruptRequestTick_ = std::chrono::time_point_cast<time_point_t::duration>(clock_t::now());
+    }
+
+private:
+    bool checkAndResetInterruptFlag() {
+        bool interrupted = true;
+        return interruptedRequested_.compare_exchange_strong(interrupted, false, std::memory_order_release, std::memory_order_acquire);
+    }
+
+    std::atomic_bool interruptedRequested_ = false;
+    std::chrono::milliseconds samplingInterval_ = std::chrono::milliseconds(20);
+    time_point_t lastInterruptRequestTick_ = std::chrono::time_point_cast<time_point_t::duration>(clock_t::now());
+    std::mutex mutex_;
+    interruptFunc_t interrupt_;
+    attachInferredSpansOnPhp_t attachInferredSpansOnPhp_;
+    std::atomic_bool phpSideBacktracePending_;
+};
+
+} // namespace elasticapm::php
\ No newline at end of file
diff --git a/prod/native/libcommon/code/PeriodicTaskExecutor.h b/prod/native/libcommon/code/PeriodicTaskExecutor.h
index 5b18c5d..57071e7 100644
--- a/prod/native/libcommon/code/PeriodicTaskExecutor.h
+++ b/prod/native/libcommon/code/PeriodicTaskExecutor.h
@@ -81,12 +81,16 @@ class PeriodicTaskExecutor : public ForkableInterface {
 
     void prefork() final {
         shutdown();
-        thread_.join();
+        if (thread_.joinable()) {
+            thread_.join();
+        }
     }
 
     void postfork([[maybe_unused]] bool child) final {
         working_ = true;
+        mutex_.lock();
         thread_ = std::thread(getThreadWorkerFunction());
+        mutex_.unlock();
         pauseCondition_.notify_all();
     }
 
diff --git a/prod/native/libcommon/code/RequestScope.h b/prod/native/libcommon/code/RequestScope.h
index cd0b5b4..c7a53fc 100644
--- a/prod/native/libcommon/code/RequestScope.h
+++ b/prod/native/libcommon/code/RequestScope.h
@@ -19,13 +19,15 @@
 
 #pragma once
 
+#include "ConfigurationStorage.h"
 #include "CommonUtils.h"
 #include "Diagnostics.h"
+#include "InferredSpans.h"
 #include "LoggerInterface.h"
+#include "PeriodicTaskExecutor.h"
 #include "PhpBridgeInterface.h"
 #include "PhpSapi.h"
 #include "SharedMemoryState.h"
-#include "ConfigurationStorage.h"
 
 #include <memory>
 #include <string_view>
@@ -35,8 +37,9 @@ namespace elasticapm::php {
 class RequestScope {
 public:
     using clearHooks_t = std::function<void()>;
+    using getPeriodicTaskExecutor_t = std::function<std::shared_ptr<PeriodicTaskExecutor>()>;
 
-    RequestScope(std::shared_ptr<LoggerInterface> log, std::shared_ptr<PhpBridgeInterface> bridge, std::shared_ptr<PhpSapi> sapi, std::shared_ptr<SharedMemoryState> sharedMemory, std::shared_ptr<ConfigurationStorage> config, clearHooks_t clearHooks) : log_(log), bridge_(std::move(bridge)), sapi_(std::move(sapi)), sharedMemory_(sharedMemory), config_(config), clearHooks_(std::move(clearHooks)) {
+    RequestScope(std::shared_ptr<LoggerInterface> log, std::shared_ptr<PhpBridgeInterface> bridge, std::shared_ptr<PhpSapi> sapi, std::shared_ptr<SharedMemoryState> sharedMemory, std::shared_ptr<InferredSpans> inferredSpans, std::shared_ptr<ConfigurationStorage> config, clearHooks_t clearHooks, getPeriodicTaskExecutor_t getPeriodicTaskExecutor) : log_(log), bridge_(std::move(bridge)), sapi_(std::move(sapi)), sharedMemory_(sharedMemory), inferredSpans_(std::move(inferredSpans)), config_(config), clearHooks_(std::move(clearHooks)), getPeriodicTaskExecutor_(std::move(getPeriodicTaskExecutor)) {
     }
 
     void onRequestInit() {
@@ -88,6 +91,21 @@ class RequestScope {
 
         bootstrapSuccessfull_ = bootstrapPHPSideInstrumentation(requestStartTime);
 
+        if (bootstrapSuccessfull_ && (*config_)->inferred_spans_enabled) {
+            auto periodicTaskExecutor = getPeriodicTaskExecutor_();
+            auto interval = (*config_)->inferred_spans_sampling_interval;
+
+            if (interval.count() == 0) {
+                interval = std::chrono::milliseconds{ConfigurationSnapshot().ELASTIC_OTEL_CFG_OPT_NAME_INFERRED_SPANS_SAMPLING_INTERVAL};
+                ELOGF_DEBUG(log_, REQUEST, "inferred spans thread interval too low, forced to default %zums", interval.count());
+            }
+
+            ELOGF_DEBUG(log_, REQUEST, "resuming inferred spans thread with sampling interval %zums", interval.count());
+            inferredSpans_->setInterval(interval);
+            inferredSpans_->reset();
+            periodicTaskExecutor->setInterval(interval);
+            periodicTaskExecutor->resumePeriodicTasks();
+        }
     }
 
     void onRequestShutdown() {
@@ -103,6 +121,11 @@ class RequestScope {
             return;
         }
 
+        if ((*config_)->inferred_spans_enabled) {
+            ELOGF_DEBUG(log_, REQUEST, "pausing inferred spans thread");
+            getPeriodicTaskExecutor_()->suspendPeriodicTasks();
+        }
+
         if (!bridge_->callPHPSideExitPoint()) {
             ELOGF_ERROR(log_, REQUEST, "callPHPSideExitPoint failed");
         }
@@ -154,8 +177,10 @@ class RequestScope {
     std::shared_ptr<PhpBridgeInterface> bridge_;
     std::shared_ptr<PhpSapi> sapi_;
     std::shared_ptr<SharedMemoryState> sharedMemory_;
+    std::shared_ptr<InferredSpans> inferredSpans_;
     std::shared_ptr<ConfigurationStorage> config_;
     clearHooks_t clearHooks_;
+    getPeriodicTaskExecutor_t getPeriodicTaskExecutor_;
     size_t requestCounter_ = 0;
     bool bootstrapSuccessfull_ = false;
     bool preloadDetected_ = false;
diff --git a/prod/native/libcommon/test/PeriodicTaskExecutorTest.cpp b/prod/native/libcommon/test/PeriodicTaskExecutorTest.cpp
index e330850..1a6e555 100644
--- a/prod/native/libcommon/test/PeriodicTaskExecutorTest.cpp
+++ b/prod/native/libcommon/test/PeriodicTaskExecutorTest.cpp
@@ -66,7 +66,13 @@ TEST(PeriodicTaskExecutorTest, resumeAfterFork) {
 
     periodicTaskExecutor_.setInterval(20ms);
 
-    pthread_atfork(fh_prepare, fh_parent, fh_child);
+
+    static bool pthread_atfork_called = false;
+
+    if (!pthread_atfork_called) {
+        pthread_atfork(fh_prepare, fh_parent, fh_child);
+        pthread_atfork_called = true;
+    }
 
     periodicTaskExecutor_.resumePeriodicTasks();
     std::this_thread::sleep_for(100ms);
@@ -79,7 +85,7 @@ TEST(PeriodicTaskExecutorTest, resumeAfterFork) {
 
     ASSERT_GE(counter.load(), 13); // should be 15 in ideal world
     if (pid == 0) {
-        exit(0);
+        exit(testing::Test::HasFailure());
     }
 }
 
diff --git a/prod/native/libphpbridge/code/PhpBridge.cpp b/prod/native/libphpbridge/code/PhpBridge.cpp
index 37b665d..566c09d 100644
--- a/prod/native/libphpbridge/code/PhpBridge.cpp
+++ b/prod/native/libphpbridge/code/PhpBridge.cpp
@@ -54,36 +54,16 @@ std::optional<std::string_view> PhpBridge::getCurrentExceptionMessage() const {
 }
 
 bool PhpBridge::callInferredSpans(std::chrono::milliseconds duration) const {
-    auto phpPartFacadeClass = findClassEntry("elastic\\apm\\impl\\phppartfacade"sv);
+    auto phpPartFacadeClass = findClassEntry("elastic\\otel\\phppartfacade"sv);
     if (!phpPartFacadeClass) {
         return false;
     }
 
-    auto objectOfPhpPartFacade = getClassStaticPropertyValue(phpPartFacadeClass, "singletonInstance"sv);
-    if (!objectOfPhpPartFacade || Z_TYPE_P(objectOfPhpPartFacade) != IS_OBJECT) {
-        return false;
-    }
-
-    auto transactionForExtensionRequest = getClassPropertyValue(phpPartFacadeClass, objectOfPhpPartFacade, "transactionForExtensionRequest"sv);
-    if (!isObjectOfClass(transactionForExtensionRequest, "Elastic\\Apm\\Impl\\TransactionForExtensionRequest")) {
-        return false;
-    }
-
-    zend_class_entry *ceTransactionForExtensionRequest = Z_OBJCE_P(transactionForExtensionRequest);
-    if (!ceTransactionForExtensionRequest) {
-        return false;
-    }
-
-    zval *inferredSpansManager = getClassPropertyValue(ceTransactionForExtensionRequest, transactionForExtensionRequest, "inferredSpansManager"sv);
-    if (!isObjectOfClass(inferredSpansManager, "Elastic\\Apm\\Impl\\InferredSpansManager")) {
-        return false;
-    }
+    bool internal = (EG(current_execute_data) && EG(current_execute_data)->func->type == ZEND_INTERNAL_FUNCTION);
 
     AutoZval rv;
-    AutoZval params;
-    params.setLong(duration.count());
-
-    return callMethod(inferredSpansManager, "handleAutomaticCapturing"sv, params.get(), 1, rv.get());
+    std::array<AutoZval, 2> params{duration.count(), internal};
+    return callMethod(nullptr, "\\Elastic\\OTel\\PhpPartFacade::inferredSpans"sv, params.data()->get(), params.size(), rv.get());
 }
 
 std::string_view PhpBridge::getPhpSapiName() const {
@@ -248,7 +228,34 @@ zval *getClassPropertyValue(zend_class_entry *ce, zend_object *object, std::stri
 #endif
 }
 
+bool forceSetObjectPropertyValue(zend_object *object, zend_string *propertyName, zval *value) {
+    auto ce = object->ce;
 
+    decltype(zend_property_info::flags) originalFlags = 0;
+    bool flagChanged = false;
+
+    if (zend_hash_num_elements(&ce->properties_info) == 0) {
+        return false;
+    }
+    zval *zv = zend_hash_find(&ce->properties_info, propertyName);
+    if (!zv) {
+        return false;
+    }
+
+    auto prop_info = static_cast<zend_property_info *>(Z_PTR_P(zv));
+
+    originalFlags = prop_info->flags;
+    if (prop_info->flags & ZEND_ACC_READONLY) {
+        prop_info->flags = prop_info->flags & ~ZEND_ACC_READONLY;
+    }
+
+    zend_update_property_ex(object->ce, object, propertyName, value);
+
+    if (flagChanged) {
+        prop_info->flags = originalFlags;
+    }
+    return true;
+}
 
 bool callMethod(zval *object, std::string_view methodName, zval arguments[], int32_t argCount, zval *returnValue) {
     elasticapm::utils::callOnScopeExit callOnExit([exceptionState = saveExceptionState()]() { restoreExceptionState(exceptionState); });
@@ -396,5 +403,4 @@ void getCurrentException(zval *zv, zend_object *exception) {
     }
 }
 
-
 } // namespace elasticapm::php
diff --git a/prod/native/libphpbridge/code/PhpBridge.h b/prod/native/libphpbridge/code/PhpBridge.h
index f1dc17d..f1a091a 100644
--- a/prod/native/libphpbridge/code/PhpBridge.h
+++ b/prod/native/libphpbridge/code/PhpBridge.h
@@ -81,6 +81,6 @@ void getFunctionDeclarationFileName(zval *zv, zend_execute_data *ex);
 void getFunctionDeclarationLineNo(zval *zv, zend_execute_data *ex);
 void getFunctionReturnValue(zval *zv, zval *retval);
 void getCurrentException(zval *zv, zend_object *exception);
-
+bool forceSetObjectPropertyValue(zend_object *object, zend_string *propertyName, zval *value);
 
 } // namespace elasticapm::php
\ No newline at end of file
diff --git a/prod/php/ElasticOTel/InferredSpans/InferredSpans.php b/prod/php/ElasticOTel/InferredSpans/InferredSpans.php
new file mode 100644
index 0000000..56fcc09
--- /dev/null
+++ b/prod/php/ElasticOTel/InferredSpans/InferredSpans.php
@@ -0,0 +1,411 @@
+<?php
+
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+declare(strict_types=1);
+
+namespace Elastic\OTel\InferredSpans;
+
+use OpenTelemetry\API\Globals;
+use OpenTelemetry\API\Behavior\LogsMessagesTrait;
+use OpenTelemetry\API\Trace\SpanKind;
+use OpenTelemetry\API\Trace\TracerInterface;
+use OpenTelemetry\Context\Context;
+use OpenTelemetry\SemConv\TraceAttributes;
+use OpenTelemetry\API\Common\Time\Clock;
+use OpenTelemetry\SemConv\Version;
+use OpenTelemetry\Context\ContextInterface;
+use WeakReference;
+
+/**
+ * @phpstan-type ExtendedStackTraceFrame array{function: string, line?: int, file?: string, class?: class-string, type?: '->'|'::', span: \WeakReference<\OpenTelemetry\API\Trace\SpanInterface>,
+ *  context: \WeakReference<\OpenTelemetry\Context\ContextInterface>, scope: \WeakReference<\OpenTelemetry\Context\ContextStorageScopeInterface>, stackTraceId: int }
+ * @phpstan-type ExtendedStackTrace array<string|int, ExtendedStackTraceFrame>
+ * @phpstan-type DebugBackTraceFrame array{function: string, line?: int, file?: string, class?: class-string, type?: '->'|'::', args?: array<mixed>, object?: object}
+ * @phpstan-type DebugBackTrace array<int<0, max>, DebugBackTraceFrame>
+ */
+class InferredSpans
+{
+    use LogsMessagesTrait;
+
+    private const METADATA_SPAN = 'span';
+    private const METADATA_CONTEXT = 'context';
+    private const METADATA_SCOPE = 'scope';
+    private const METADATA_STACKTRACE_ID = 'stackTraceId';
+
+    private const MILLIS_TO_NANOS = 1_000_000;
+    private const FRAMES_TO_SKIP = 2;
+
+    private TracerInterface $tracer;
+    /** @var ExtendedStackTrace */
+    private array $lastStackTrace;
+    private int $stackTraceId = 0;
+
+    private bool $shutdown;
+
+
+    public function __construct(private readonly bool $spanReductionEnabled, private readonly bool $attachStackTrace, private readonly float $minSpanDuration)
+    {
+        $this->tracer = Globals::tracerProvider()->getTracer(
+            'co.elastic.php.elastic-inferred-spans',
+            null,
+            Version::VERSION_1_25_0->url(),
+        );
+
+        self::logDebug('spanReductionEnabled ' . $spanReductionEnabled . ' attachStackTrace ' . $attachStackTrace . ' minSpanDuration ' . $minSpanDuration);
+
+        $this->lastStackTrace = array();
+        $this->shutdown = false;
+    }
+
+    // $durationMs - duration between interrupt request and interrupt occurence
+    public function captureStackTrace(int $durationMs, bool $topFrameIsInternalFunction): void
+    {
+        self::logDebug("captureStackTrace topFrameInternal: $topFrameIsInternalFunction, duration: $durationMs ms shutdown: " . $this->shutdown);
+
+        if ($this->shutdown) {
+            return;
+        }
+
+        try {
+            /* @var DebugBackTrace $stackTrace */
+            $stackTrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+
+            array_splice($stackTrace, 0, InferredSpans::FRAMES_TO_SKIP); // skip PhpFacade/Inferred spans logic frames
+            $apmFramesFilteredOutCount = $this->filterOutAPMFrames($stackTrace);
+            $apmFramesFilteredOutCount = null;
+
+            $this->compareStackTraces($stackTrace, $durationMs, $topFrameIsInternalFunction, $apmFramesFilteredOutCount);
+        } catch (\Throwable $throwable) {
+            self::logError($throwable->__toString());
+        }
+    }
+
+    public function shutdown(): void
+    {
+        self::logDebug("shutdown");
+        $this->shutdown = true;
+        $fakeTrace = [];
+        $this->compareStackTraces($fakeTrace, 0, false, 0);
+    }
+
+    /**
+     * @param DebugBackTrace $stackTrace
+    */
+    private function compareStackTraces(array $stackTrace, int $durationMs, bool $topFrameIsInternalFunction, ?int $apmFramesFilteredOut): void
+    {
+        $this->stackTraceId++;
+
+        $identicalFramesCount = $this->getHowManyStackFramesAreIdenticalFromStackBottom($stackTrace);
+        self::logDebug("Same frames count: " . $identicalFramesCount); //, [$stackTrace, $this->lastStackTrace]);
+
+        $lastStackTraceCount = count($this->lastStackTrace);
+        $oldFramesCount = $lastStackTraceCount - $identicalFramesCount;
+
+        // on previous stack trace - end all spans above identical frames
+        $previousFrameStackTraceId = -1;
+        $forceParentChangeFailed = false;
+
+        for ($index = 0; $index < $oldFramesCount; $index++) {
+            $endEpochNanos = null;
+             // if last frame was internal function, so duraton contains it's time, previous ones ended between sampling interval - they're shorter
+            if ($topFrameIsInternalFunction) {
+                $endEpochNanos = $this->getStartTime($durationMs);
+            }
+
+            $dropSpan = false;
+            if ($this->spanReductionEnabled) {
+                $dropSpan = $this->shouldReduceFrame($index, $oldFramesCount, $previousFrameStackTraceId, $forceParentChangeFailed);
+            }
+
+            $this->endFrameSpan($this->lastStackTrace[$index], $dropSpan, $endEpochNanos);
+
+            unset($this->lastStackTrace[$index]); // remove ended frame
+        }
+
+        // reindex array
+        $this->lastStackTrace = array_values($this->lastStackTrace);
+
+        $stackTraceCount = count($stackTrace);
+        if ($stackTraceCount == $identicalFramesCount) {
+            // no frames to start
+            return;
+        }
+
+        $first = true;
+
+        // start spans for all frames below identical frames
+
+        for ($index = $stackTraceCount - $identicalFramesCount - 1; $index >= 0; $index--) {
+            if ($first && $apmFramesFilteredOut && !empty($this->lastStackTrace)) {
+                self::logDebug("Going to start span in previous span context");
+                $newFrame = $this->startFrameSpan($stackTrace[$index], $durationMs, $this->lastStackTrace[0][self::METADATA_CONTEXT]->get(), $this->stackTraceId);
+            } else {
+                $newFrame = $this->startFrameSpan($stackTrace[$index], $durationMs, null, $this->stackTraceId);
+            }
+
+            $first = false;
+
+            if ($this->attachStackTrace) {
+                $newFrame[self::METADATA_SPAN]->get()?->setAttribute(TraceAttributes::CODE_STACKTRACE, $this->getStackTrace($this->lastStackTrace));
+            }
+
+            if ($index == 0 && $topFrameIsInternalFunction) {
+                $this->endFrameSpan($newFrame, false, null); // we don't need to save newest internal frame, it ended
+            } else {
+                array_unshift($this->lastStackTrace, $newFrame); // push-copy frame in front of last stack trace for next interruption processing
+            }
+        }
+    }
+
+    private function getStartTime(int $durationMs): int
+    {
+        return Clock::getDefault()->now() - $durationMs * self::MILLIS_TO_NANOS;
+    }
+
+    /** @param-out DebugBackTrace $stackTrace
+     *  @param DebugBackTrace $stackTrace
+     *  @return ?int
+     */
+    private function filterOutAPMFrames(array &$stackTrace): ?int
+    {
+       // Filter out Elastic and Otel stack frames
+        $cutIndex = null;
+        for ($index = count($stackTrace) - 1; $index >= 0; $index--) {
+            /** @var DebugBackTraceFrame $frame */
+            $frame = $stackTrace[$index];
+            if (
+                array_key_exists('class', $frame) &&
+                (str_starts_with($frame['class'], 'OpenTelemetry\\') ||
+                str_starts_with($frame['class'], 'Elastic\\'))
+            ) {
+                $cutIndex = $index;
+                break;
+            }
+        }
+
+        if ($cutIndex !== null) {
+            array_splice($stackTrace, 0, $cutIndex + 1);
+        }
+        return $cutIndex;
+    }
+
+    /** @param DebugBackTrace $stackTrace */
+    private function getHowManyStackFramesAreIdenticalFromStackBottom(array $stackTrace): int
+    {
+        // Helper function to check if two frames are identical
+        /** @param DebugBackTraceFrame $frame1
+         *  @param DebugBackTraceFrame $frame2
+         */
+        $isSameFrame = function (array $frame1, array $frame2) {
+            $keysToCompare = ['class', 'function', 'file', 'line', 'type'];
+            foreach ($keysToCompare as $key) {
+                if (($frame1[$key] ?? null) !== ($frame2[$key] ?? null)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        $stackTraceCount = count($stackTrace);
+        $lastStackTraceCount = count($this->lastStackTrace);
+
+        $count = min($stackTraceCount, $lastStackTraceCount);
+
+        $index = 0;
+        for ($index = 1; $index <= $count; $index++) {
+            $stFrame = &$stackTrace[$stackTraceCount - $index];
+            $lastStFrame = &$this->lastStackTrace[$lastStackTraceCount - $index];
+
+            if ($isSameFrame($stFrame, $lastStFrame) == false) {
+                return $index - 1;
+            }
+        }
+        return $count;
+    }
+
+    private function shouldReduceFrame(int $index, int $oldFramesCount, int &$previousFrameStackTraceId, bool &$forceParentChangeFailed): bool
+    {
+        $frameStackTraceId = $this->lastStackTrace[$index][self::METADATA_STACKTRACE_ID];
+
+        $dropSpan = $previousFrameStackTraceId == $frameStackTraceId; // if frame came from same stackTrace (interval) - we're dropping all spans above as they have same timing
+
+        $previousFrameStackTraceId = $frameStackTraceId;
+
+        if (!$dropSpan) { // if span should not be dropped, search for spans with same traceId and get parent from last one
+            // find last span with same stackTraceId
+            $lastSpanParent = null;
+            for ($i = $index + 1; $i < $oldFramesCount; $i++) {
+                if ($this->lastStackTrace[$i][self::METADATA_STACKTRACE_ID] != $frameStackTraceId) {
+                    break;
+                }
+
+                $span = $this->lastStackTrace[$i][self::METADATA_SPAN]->get();
+                if (! $span instanceof \OpenTelemetry\SDK\Trace\Span) {
+                    break;
+                }
+
+                $lastSpanParent = $span->getParentContext();
+            }
+
+            if ($lastSpanParent) {
+                $span = $this->lastStackTrace[$index][self::METADATA_SPAN]->get();
+                if (! $span instanceof \OpenTelemetry\SDK\Trace\Span) {
+                    return false;
+                }
+
+                self::logDebug(
+                    "Changing parent of span: '" . $span->getName() . "'",
+                    ['new', $lastSpanParent, 'old', $span->getParentContext()]
+                );
+
+                /** @noinspection PhpFullyQualifiedNameUsageInspection, PhpUndefinedFunctionInspection
+                 * @phpstan-ignore function.notFound
+                */
+                $forceParentChangeFailed = !force_set_object_propety_value($span, "parentSpanContext", $lastSpanParent);
+            }
+        }
+
+        if ($forceParentChangeFailed && $dropSpan) {
+            $dropSpan = false;
+        }
+
+        return $dropSpan;
+    }
+
+    /**
+     *  @param ExtendedStackTraceFrame $frame
+     */
+    private function shouldDropTooShortSpan(array $frame, ?int $endEpochNanos = null): bool
+    {
+        if ($this->minSpanDuration <= 0) {
+            return false;
+        }
+
+        $span = $frame[self::METADATA_SPAN]->get();
+        if (! $span instanceof \OpenTelemetry\SDK\Trace\Span) {
+            return false;
+        }
+
+        /** @var int */
+        $duration = 0;
+        if ($endEpochNanos) {
+            $duration = $endEpochNanos - $span->getStartEpochNanos();
+        } else {
+            $duration = $span->getDuration();
+        }
+
+        if ($duration < $this->minSpanDuration * self::MILLIS_TO_NANOS) {
+            self::logDebug('Span ' . $span->getName() . ' duration ' . intval($duration / self::MILLIS_TO_NANOS)
+                . 'ms is too short to fit within the minimum span duration limit: ' . $this->minSpanDuration . 'ms');
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     *  @param ExtendedStackTrace $stackTrace
+     */
+    private function getStackTrace($stackTrace): string
+    {
+        $str = "#0 {main}\n";
+        $id = 1;
+        foreach ($stackTrace as $frame) {
+            if (array_key_exists('file', $frame)) {
+                $file = $frame['file'] . '(' . ($frame['line'] ?? '') . ')';
+            } else {
+                $file = '[internal function]';
+            }
+
+            $str .= sprintf("#%d %s: %s%s%s\n", $id, $file, $frame['class'] ?? '', $frame['type'] ?? '', $frame['function']);
+            $id++;
+        }
+        return $str;
+    }
+
+    /**
+      *  @param DebugBackTraceFrame $frame
+      *  @return ExtendedStackTraceFrame
+      */
+    private function startFrameSpan(array $frame, int $durationMs, ?ContextInterface $parentContext, int $stackTraceId): array
+    {
+        $parent = $parentContext ? $parentContext : Context::getCurrent();
+        $builder = $this->tracer->spanBuilder(!empty($frame['function']) ? $frame['function'] : '[unknown]')
+            ->setParent($parent)
+            ->setStartTimestamp($this->getStartTime($durationMs))
+            ->setSpanKind(SpanKind::KIND_INTERNAL)
+            ->setAttribute(TraceAttributes::CODE_FUNCTION, $frame['function'])
+            ->setAttribute(TraceAttributes::CODE_FILEPATH, $frame['file'] ?? null)
+            ->setAttribute(TraceAttributes::CODE_LINENO, $frame['line'] ?? null)
+            ->setAttribute('is_inferred', true);
+
+        $span = $builder->startSpan(); //OpenTelemetry\API\Trace\SpanInterface
+        $context = $span->storeInContext($parent); //OpenTelemetry\Context\ContextInterface
+        $scope = Context::storage()->attach($context); //OpenTelemetry\Context\ContextStorageScopeInterface
+
+        /* @var ExtendedStackTraceFrame $newFrame */
+        $newFrame = $frame;
+        $newFrame[self::METADATA_SPAN] = WeakReference::create($span);
+        $newFrame[self::METADATA_CONTEXT] = WeakReference::create($context);
+        $newFrame[self::METADATA_SCOPE] = WeakReference::create($scope);
+        $newFrame[self::METADATA_STACKTRACE_ID] = $stackTraceId;
+
+        self::logDebug("Span started: " . $newFrame['function'] . " parentContext: " . ($parentContext ? "custom" : "default") . " stackTraceId: " . $stackTraceId);
+        return $newFrame;
+    }
+
+    /**
+      *  @param ExtendedStackTraceFrame $frame
+      */
+    private function endFrameSpan(array $frame, bool $dropSpan, ?int $endEpochNanos = null): void
+    {
+        /** @phpstan-ignore-next-line  */
+        if (!array_key_exists(self::METADATA_SPAN, $frame)) {
+            self::logError("endFrameSpan missing metadata.", [$frame]);
+            return;
+        }
+
+        if (!$dropSpan) {
+            $dropSpan = $this->shouldDropTooShortSpan($frame, $endEpochNanos);
+        }
+
+        $span = $frame[self::METADATA_SPAN]->get();
+        if (! $span instanceof \OpenTelemetry\SDK\Trace\Span) {
+            self::logDebug("Span in frame is not instanceof Trace\Span", [$span, $frame]);
+            return;
+        }
+
+        if ($dropSpan) {
+            self::logDebug("Span dropped:   " . $span->getName() . ' StackTraceId: ' . $frame[self::METADATA_STACKTRACE_ID]);
+            $frame[self::METADATA_SCOPE]->get()?->detach();
+            return;
+        }
+
+        $scope = Context::storage()->scope();
+        $scope?->detach();
+
+        if (!$scope || $scope->context() === Context::getCurrent()) {
+            return;
+        }
+
+        $span->end($endEpochNanos);
+        self::logDebug("Span finished:  " . $span->getName() . ' StackTraceId: ' . $frame[self::METADATA_STACKTRACE_ID]);
+    }
+}
diff --git a/prod/php/ElasticOTel/PhpPartFacade.php b/prod/php/ElasticOTel/PhpPartFacade.php
index b89993a..cccfd35 100644
--- a/prod/php/ElasticOTel/PhpPartFacade.php
+++ b/prod/php/ElasticOTel/PhpPartFacade.php
@@ -23,9 +23,10 @@
 
 namespace Elastic\OTel;
 
-use Elastic\OTel\Util\HiddenConstructorTrait;
-use Elastic\OTel\Log\ElasticLogWriter;
 use Elastic\OTel\HttpTransport\ElasticHttpTransportFactory;
+use Elastic\OTel\InferredSpans\InferredSpans;
+use Elastic\OTel\Log\ElasticLogWriter;
+use Elastic\OTel\Util\HiddenConstructorTrait;
 use OpenTelemetry\API\Globals;
 use OpenTelemetry\SDK\SdkAutoloader;
 use OpenTelemetry\API\Trace\Span;
@@ -55,6 +56,7 @@ final class PhpPartFacade
 
     private static ?self $singletonInstance = null;
     private static bool $rootSpanEnded = false;
+    private ?InferredSpans $inferredSpans = null;
 
     /**
      * Called by the extension
@@ -108,9 +110,24 @@ public static function bootstrap(string $elasticOTelNativePartVersion, int $maxE
 
             Traces\ElasticRootSpan::startRootSpan(function () {
                 PhpPartFacade::$rootSpanEnded = true;
+                if (PhpPartFacade::$singletonInstance && PhpPartFacade::$singletonInstance->inferredSpans) {
+                    PhpPartFacade::$singletonInstance->inferredSpans->shutdown();
+                }
             });
 
             self::$singletonInstance = new self();
+
+            /**
+             * @noinspection PhpFullyQualifiedNameUsageInspection, PhpUndefinedFunctionInspection
+             * @phpstan-ignore function.notFound
+             */
+            if (\elastic_otel_get_config_option_by_name('inferred_spans_enabled')) {
+                self::$singletonInstance->inferredSpans = new InferredSpans(
+                    (bool)\elastic_otel_get_config_option_by_name('inferred_spans_reduction_enabled'), // @phpstan-ignore-line
+                    (bool)\elastic_otel_get_config_option_by_name('inferred_spans_stacktrace_enabled'), // @phpstan-ignore-line
+                    \elastic_otel_get_config_option_by_name('inferred_spans_min_duration') // @phpstan-ignore-line
+                );
+            }
         } catch (Throwable $throwable) {
             BootstrapStageLogger::logCriticalThrowable($throwable, 'One of the steps in bootstrap sequence has thrown', __FILE__, __LINE__, __CLASS__, __FUNCTION__);
             return false;
@@ -120,6 +137,22 @@ public static function bootstrap(string $elasticOTelNativePartVersion, int $maxE
         return true;
     }
 
+    public static function inferredSpans(int $durationMs, bool $internalFunction): bool
+    {
+        if (self::$singletonInstance === null) {
+            BootstrapStageLogger::logDebug('Missig facade', __FILE__, __LINE__, __CLASS__, __FUNCTION__);
+            return true;
+        }
+
+        if (self::$singletonInstance->inferredSpans === null) {
+            BootstrapStageLogger::logDebug('Missig inferred spans instance', __FILE__, __LINE__, __CLASS__, __FUNCTION__);
+            return true;
+        }
+        self::$singletonInstance->inferredSpans->captureStackTrace($durationMs, $internalFunction);
+
+        return true;
+    }
+
     private static function buildElasticOTelVersion(string $nativePartVersion): string
     {
         if ($nativePartVersion === PhpPartVersion::VALUE) {