Inferred spans (#152)

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.|

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")

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

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

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());
     }

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
 };

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 {

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);

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_;
+    }
+
 
 }
 

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_;

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
 };