From f8681900693a237eb421429612dde27d12c2a685 Mon Sep 17 00:00:00 2001
From: Pawel Filipczak <pawel.filipczak@elastic.co>
Date: Tue, 22 Oct 2024 22:01:23 +0200
Subject: [PATCH 1/2] Selective logging level per feature (#103)

---
 .gitignore                                    |   1 +
 NOTICE                                        |  51 ++++++--
 composer.json                                 |   2 +-
 docs/configure.md                             |   1 +
 elastic-otel-php.properties                   |   1 +
 prod/native/CMakeLists.txt                    |   1 +
 .../elastic_set_default_build_options.cmake   |  12 +-
 prod/native/conanfile.txt                     |   1 +
 prod/native/extension/code/Hooking.cpp        |  10 +-
 .../code/InternalFunctionInstrumentation.cpp  |  58 ++++-----
 prod/native/extension/code/ModuleEntry.cpp    |   8 +-
 .../native/extension/code/ModuleFunctions.cpp |  56 ++++++++-
 .../extension/code/ModuleIniEntries.cpp       |   2 +-
 prod/native/extension/code/ModuleInit.cpp     |   8 +-
 prod/native/libcommon/code/AgentGlobals.cpp   |  13 ++-
 prod/native/libcommon/code/CMakeLists.txt     |   3 +
 prod/native/libcommon/code/CommonUtils.cpp    |  32 +++++
 prod/native/libcommon/code/CommonUtils.h      |   7 ++
 .../libcommon/code/ConfigurationManager.h     |   1 +
 .../libcommon/code/ConfigurationSnapshot.h    |   2 +
 prod/native/libcommon/code/LogFeature.cpp     |  37 ++++++
 prod/native/libcommon/code/LogFeature.h.in    |  41 +++++++
 prod/native/libcommon/code/Logger.cpp         |  24 ++++
 prod/native/libcommon/code/Logger.h           |   6 +
 prod/native/libcommon/code/LoggerInterface.h  |  33 ++++--
 prod/native/libcommon/code/RequestScope.h     |  26 ++---
 .../libcommon/code/transport/CurlSender.cpp   |   2 +-
 .../libcommon/code/transport/HttpEndpoints.h  |   2 +-
 .../code/transport/HttpTransportAsync.h       |  34 +++---
 .../native/libcommon/test/CommonUtilsTest.cpp |  79 +++++++++++--
 prod/native/libphpbridge/code/OpCache.cpp     |   8 +-
 prod/php/ElasticOTel/BootstrapStageLogger.php |   5 +-
 .../ElasticOTel/Log/LogFeature.php.template   |  30 +++++
 .../ElasticOTel/PhpPartVersion.php.template   |   2 +-
 tools/build/configure_php_templates.sh        | 110 ++++++++++++++++++
 tools/build/generate_php_part_version.sh      |  39 -------
 36 files changed, 587 insertions(+), 161 deletions(-)
 create mode 100644 prod/native/libcommon/code/LogFeature.cpp
 create mode 100644 prod/native/libcommon/code/LogFeature.h.in
 create mode 100644 prod/php/ElasticOTel/Log/LogFeature.php.template
 create mode 100755 tools/build/configure_php_templates.sh
 delete mode 100755 tools/build/generate_php_part_version.sh

diff --git a/.gitignore b/.gitignore
index af7301a..d086643 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 #generated version file
 prod/php/ElasticOTel/PhpPartVersion.php
+prod/php/ElasticOTel/Log/LogFeature.php
 
 # Mac
 .DS_Store
diff --git a/NOTICE b/NOTICE
index 8d2edca..e7b1d17 100644
--- a/NOTICE
+++ b/NOTICE
@@ -9,10 +9,10 @@ This project depends on folliwng packages:
 --------------------------------------------------------------------------------
 
 Package name: Boost C++ Libraries
-Version: 1.83.0
+Version: 1.86.0
 Authors: Boost contributors (https://github.com/boostorg/boost/graphs/contributors)
 Licenses: BSL-1.0 license
-URL: https://github.com/boostorg/boost/tree/boost-1.83.0
+URL: https://github.com/boostorg/boost/tree/boost-1.86.0
 
 
 LICENSE_1.0.txt content:
@@ -43,10 +43,10 @@ DEALINGS IN THE SOFTWARE.
 --------------------------------------------------------------------------------
 
 Package name: libcurl
-Version: 8.0.1
+Version: 8.10.1
 Authors: Daniel Stenberg, <daniel@haxx.se>, and many contributors
-Licenses: curl (https://github.com/curl/curl/blob/curl-8_0_1/COPYING)
-URL: https://github.com/curl/curl/blob/curl-8_0_1/
+Licenses: curl (https://github.com/curl/curl/blob/curl-8_10_1/COPYING)
+URL: https://github.com/curl/curl/blob/curl-8_10_1/
 
 curl/COPYING content:
 
@@ -73,13 +73,16 @@ Except as contained in this notice, the name of a copyright holder shall not
 be used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization of the copyright holder.
 
+Notice:
+Curl contains pieces of source code that is Copyright (c) 1998, 1999 Kungliga Tekniska Högskolan. This notice is included here to comply with the distribution terms.
+
 --------------------------------------------------------------------------------
 
 Package name: libunwind
-Version: 1.6.2
+Version: 1.8.1
 Authors: David Mosberger <dmosberger@gmail.org>
 Licenses: MIT
-URL: https://github.com/libunwind/libunwind/tree/b3ca1b59a795a617877c01fe5d299ab7a07ff29d
+URL: https://github.com/libunwind/libunwind/tree/9cc4d98b22ae57bc1d8c253988feb85d4298a634
 
 No NOTICE file found
 LICENSE content:
@@ -159,3 +162,37 @@ Copyright notice:
 
 --------------------------------------------------------------------------------
 
+--------------------------------------------------------------------------------
+
+Package name: magic_enum
+Version: 0.9.6
+Authors: Jean-loup Gailly <jloup@gzip.org> and Mark Adler <madler@alumni.caltech.edu>
+Licenses: MIT (https://github.com/Neargye/magic_enum/blob/v0.9.6/LICENSE)
+URL: https://github.com/Neargye/magic_enum/tree/v0.9.6
+
+No NOTICE file found
+LICENSE content:
+MIT License
+
+Copyright (c) 2019 - 2024 Daniil Goncharov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------------------------------------------------------------------
+
diff --git a/composer.json b/composer.json
index cacf77f..dc2fd54 100644
--- a/composer.json
+++ b/composer.json
@@ -51,7 +51,7 @@
     },
     "scripts": {
         "pre-autoload-dump": [
-            "./tools/build/generate_php_part_version.sh"
+            "./tools/build/configure_php_templates.sh"
         ],
         "parallel-lint": [
             "parallel-lint ./prod/php/ ./tests/ --exclude ./tests/polyfills/"
diff --git a/docs/configure.md b/docs/configure.md
index 96c4bc1..63131fc 100644
--- a/docs/configure.md
+++ b/docs/configure.md
@@ -67,4 +67,5 @@ _Currently there are no additional `OTEL_` options waiting to be contributed ups
 |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.
 | <option> | <default value> | <description> |
diff --git a/elastic-otel-php.properties b/elastic-otel-php.properties
index b05f05a..f2567f1 100644
--- a/elastic-otel-php.properties
+++ b/elastic-otel-php.properties
@@ -1,3 +1,4 @@
 version=0.2.0
 supported_php_versions=(80 81 82 83)
 php_headers_version=2.0
+logger_features_enum_values=ALL=0,MODULE=1,REQUEST=2,TRANSPORT=3,BOOTSTRAP=4,HOOKS=5,INSTRUMENTATION=6
diff --git a/prod/native/CMakeLists.txt b/prod/native/CMakeLists.txt
index 82f501f..fe09b88 100644
--- a/prod/native/CMakeLists.txt
+++ b/prod/native/CMakeLists.txt
@@ -82,6 +82,7 @@ find_package(CURL 8.10.1 REQUIRED)
 find_package(libunwind 1.8.1 REQUIRED)
 find_package(Boost 1.86 REQUIRED CONFIG)
 find_package(GTest 1.15.0 REQUIRED)
+find_package(magic_enum 0.9.6 REQUIRED)
 
 foreach(_php_version ${_supported_php_versions})
     find_package(php-headers-${_php_version} ${_PROJECT_PROPERTIES_PHP_HEADERS_VERSION} REQUIRED)
diff --git a/prod/native/building/cmake/elastic_set_default_build_options.cmake b/prod/native/building/cmake/elastic_set_default_build_options.cmake
index d583fb0..6ab90ae 100644
--- a/prod/native/building/cmake/elastic_set_default_build_options.cmake
+++ b/prod/native/building/cmake/elastic_set_default_build_options.cmake
@@ -5,7 +5,7 @@ set(_ELASTIC_FAIL_ON_ERROR true)
 set(_ELASTIC_WARN_ON_UNINITIALIZED true)
 
 
-# determine build type and set 
+# determine build type and set
 set(MUSL_BUILD false)
 
 set_property(GLOBAL PROPERTY GLOBAL_DEPENDS_NO_CYCLES ON) # https://cmake.org/cmake/help/latest/prop_gbl/GLOBAL_DEPENDS_NO_CYCLES.html
@@ -15,7 +15,7 @@ set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)   # https://github.com/ComputationalRadiat
 set(CMAKE_DISABLE_SOURCE_CHANGES  ON)
 set(CMAKE_CXX_EXTENSIONS OFF)           # https://cmake.org/cmake/help/latest/prop_tgt/CXX_EXTENSIONS.html#prop_tgt:CXX_EXTENSIONS
 set(CMAKE_CXX_STANDARD_REQUIRED ON)     # https://cmake.org/cmake/help/latest/prop_tgt/CXX_STANDARD_REQUIRED.html#prop_tgt:CXX_STANDARD_REQUIRED
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)       # https://cmake.org/cmake/help/latest/variable/CMAKE_INCLUDE_CURRENT_DIR.html
 
 set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)  # include runtime search path for shared libs
@@ -33,8 +33,8 @@ find_package(Threads REQUIRED)
 
 
 # Keep output small as possible and manually control what we want to link with binaries
-set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "") 
-set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "") 
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "")
 
 # Workaround to enable globally staticaly linked libgcc and libstdc++ - don't need to be enabled foreach target
 # linking with libdl and libpthreads
@@ -45,7 +45,7 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-lib
 add_compile_options("-pipe") # don't use temporary files but pipe data to linker
 
 # Set up optimizations
-if(RELEASE_BUILD) 
+if(RELEASE_BUILD)
     add_compile_options("-O2"
                         "-g"
     )
@@ -86,7 +86,7 @@ endif()
 # C++ only switches
 add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Wno-register>")
 add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-Wnon-virtual-dtor>")
-add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-fdiagnostics-show-template-tree>") # print template mismatch as tree - much more user friendly 
+add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:-fdiagnostics-show-template-tree>") # print template mismatch as tree - much more user friendly
 
 # C only switches
 add_compile_options("$<$<COMPILE_LANGUAGE:C>:-Wstrict-prototypes>")
diff --git a/prod/native/conanfile.txt b/prod/native/conanfile.txt
index 54c0402..39b8d9f 100644
--- a/prod/native/conanfile.txt
+++ b/prod/native/conanfile.txt
@@ -1,6 +1,7 @@
 [requires]
 libcurl/8.10.1
 libunwind/1.8.1
+magic_enum/0.9.6
 boost/1.86.0
 gtest/1.15.0
 php-headers-80/2.0
diff --git a/prod/native/extension/code/Hooking.cpp b/prod/native/extension/code/Hooking.cpp
index 4e1604b..2a4f41f 100644
--- a/prod/native/extension/code/Hooking.cpp
+++ b/prod/native/extension/code/Hooking.cpp
@@ -47,10 +47,10 @@ void elastic_observer_error_cb(int type, zend_string *error_filename, uint32_t e
 #endif
     std::string_view msg = message && ZSTR_VAL(message) ? std::string_view{ZSTR_VAL(message), ZSTR_LEN(message)} : std::string_view{};
 
-    ELOG_DEBUG(ELASTICAPM_G(globals)->logger_, "elastic_observer_error_cb type: %d, fn: " PRsv ":%d, msg: " PRsv " ED: %p", type, PRsvArg(fileName), error_lineno, PRsvArg(msg), EG(current_execute_data));
+    ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "elastic_observer_error_cb type: %d, fn: " PRsv ":%d, msg: " PRsv " ED: %p", type, PRsvArg(fileName), error_lineno, PRsvArg(msg), EG(current_execute_data));
     static bool errorHandling = false;
     if (errorHandling) {
-        ELOG_WARNING(ELASTICAPM_G(globals)->logger_, "elastic_observer_error_cb detected error handler loop, skipping error handler");
+        ELOGF_WARNING(ELASTICAPM_G(globals)->logger_, HOOKS, "elastic_observer_error_cb detected error handler loop, skipping error handler");
         return;
     }
 
@@ -61,16 +61,16 @@ void elastic_observer_error_cb(int type, zend_string *error_filename, uint32_t e
         if (hash) {
             if (ELASTICAPM_G(globals)->logger_ && ELASTICAPM_G(globals)->logger_->doesMeetsLevelCondition(LogLevel::logLevel_debug)) {
                 auto [cls, fun] = getClassAndFunctionName(EG(current_execute_data));
-                ELOG_DEBUG(ELASTICAPM_G(globals)->logger_, "elastic_observer_error_cb currentED: %p currentEXception: %p hash: 0x%X " PRsv "::" PRsv, EG(current_execute_data), EG(exception), hash, PRsvArg(cls), PRsvArg(fun));
+                ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "elastic_observer_error_cb currentED: %p currentEXception: %p hash: 0x%X " PRsv "::" PRsv, EG(current_execute_data), EG(exception), hash, PRsvArg(cls), PRsvArg(fun));
             }
 
             auto callbacks = reinterpret_cast<InstrumentedFunctionHooksStorage_t *>(EAPM_GL(hooksStorage_).get())->find(hash);
             if (callbacks) {
-                ELOG_DEBUG(ELASTICAPM_G(globals)->logger_, "elastic_observer_error_cb type: %d, fn: " PRsv ":%d, msg: " PRsv ". Skipping default error instrumentation because function is instrumented and error will be passed to posthook", type, PRsvArg(fileName), error_lineno, PRsvArg(msg));
+                ELOGF_DEBUG(ELASTICAPM_G(globals)->logger_, HOOKS, "elastic_observer_error_cb type: %d, fn: " PRsv ":%d, msg: " PRsv ". Skipping default error instrumentation because function is instrumented and error will be passed to posthook", type, PRsvArg(fileName), error_lineno, PRsvArg(msg));
                 return;
             }
         } else {
-            ELOG_WARNING(ELASTICAPM_G(globals)->logger_, "elastic_observer_error_cb currentED: %p currentEXception: %p func null, msg: " PRsv, EG(current_execute_data), EG(exception), PRsvArg(msg));
+            ELOGF_WARNING(ELASTICAPM_G(globals)->logger_, HOOKS, "elastic_observer_error_cb currentED: %p currentEXception: %p func null, msg: " PRsv, EG(current_execute_data), EG(exception), PRsvArg(msg));
         }
     }
 
diff --git a/prod/native/extension/code/InternalFunctionInstrumentation.cpp b/prod/native/extension/code/InternalFunctionInstrumentation.cpp
index 6962989..dce91ac 100644
--- a/prod/native/extension/code/InternalFunctionInstrumentation.cpp
+++ b/prod/native/extension/code/InternalFunctionInstrumentation.cpp
@@ -48,7 +48,7 @@ void handleAndReleaseHookException(zend_object *exception) {
         return;
     }
 
-    ELOG_ERROR(EAPM_GL(logger_), "Instrumentation hook error: %s", exceptionToString(exception).c_str());
+    ELOGF_ERROR(EAPM_GL(logger_), INSTRUMENTATION, "Instrumentation hook error: %s", exceptionToString(exception).c_str());
     OBJ_RELEASE(exception);
 }
 
@@ -89,7 +89,7 @@ void argsPostProcessing(AutoZval &functionArgs, AutoZval &returnValue) {
     uint32_t requiredArgsCount = execute_data->func->type == ZEND_INTERNAL_FUNCTION ? ZEND_CALL_NUM_ARGS(execute_data) : execute_data->func->op_array.last_var;
     uint32_t initalCallNumArgs = ZEND_CALL_NUM_ARGS(execute_data);
 
-    ELOG_DEBUG(EAPM_GL(logger_), "argsPostProcessing requiredArgsCount: %d initialCallNumArgs: %d", requiredArgsCount, initalCallNumArgs);
+    ELOGF_DEBUG(EAPM_GL(logger_), INSTRUMENTATION, "argsPostProcessing requiredArgsCount: %d initialCallNumArgs: %d", requiredArgsCount, initalCallNumArgs);
 
     uint32_t highestArgIdx = 0;
     ZEND_HASH_FOREACH_KEY_VAL(Z_ARR_P(returnValue.get()), argIndex, argStrKey, argValue) {
@@ -98,12 +98,12 @@ void argsPostProcessing(AutoZval &functionArgs, AutoZval &returnValue) {
         }
     } ZEND_HASH_FOREACH_END();
 
-    ELOG_DEBUG(EAPM_GL(logger_), "argsPostProcessing highestArgIdx: %d vm_stack free: %d", highestArgIdx, EG(vm_stack_end) - EG(vm_stack_top));
+    ELOGF_DEBUG(EAPM_GL(logger_), INSTRUMENTATION, "argsPostProcessing highestArgIdx: %d vm_stack free: %d", highestArgIdx, EG(vm_stack_end) - EG(vm_stack_top));
 
     // extending stack and undefining potential gaps
     if (highestArgIdx + 1 > initalCallNumArgs) {
         uint32_t howManyArgsToAdd = highestArgIdx + 1 - initalCallNumArgs;
-        ELOG_DEBUG(EAPM_GL(logger_), "postProcessing trying extend stack frame with %d arguments", howManyArgsToAdd);
+        ELOGF_DEBUG(EAPM_GL(logger_), INSTRUMENTATION, "postProcessing trying extend stack frame with %d arguments", howManyArgsToAdd);
 
         zend_vm_stack_extend_call_frame(&execute_data, initalCallNumArgs, howManyArgsToAdd);
 
@@ -118,16 +118,16 @@ void argsPostProcessing(AutoZval &functionArgs, AutoZval &returnValue) {
 
     ZEND_HASH_FOREACH_KEY_VAL(Z_ARR_P(returnValue.get()), argIndex, argStrKey, argValue) {
         if (argStrKey) {
-            ELOG_DEBUG(EAPM_GL(logger_), "argsPostProcessing str: %s", ZSTR_VAL(argStrKey));
+            ELOGF_DEBUG(EAPM_GL(logger_), INSTRUMENTATION, "argsPostProcessing str: %s", ZSTR_VAL(argStrKey));
 
             try {
                 argIndex = getFunctionArgumentIndex(argStrKey, execute_data->func);
             } catch (std::exception const &e) {
-                ELOG_WARNING(EAPM_GL(logger_), "postProcessing argument index not found for: '%s'", ZSTR_VAL(argStrKey));
+                ELOGF_WARNING(EAPM_GL(logger_), INSTRUMENTATION, "postProcessing argument index not found for: '%s'", ZSTR_VAL(argStrKey));
                 continue;
             }
         }
-        ELOG_DEBUG(EAPM_GL(logger_), "argsPostProcessing idx: %d", argIndex);
+        ELOGF_DEBUG(EAPM_GL(logger_), INSTRUMENTATION, "argsPostProcessing idx: %d", argIndex);
 
         zval *target = nullptr;
         if (argIndex < requiredArgsCount) {
@@ -209,7 +209,7 @@ void callPostHook(AutoZval &hook, zval *return_value, zend_object *exception, ze
     // thre is no way to distinguish if posthook returned NULL, becuase in PHP functions are always returning NULL, even if there is no return keyword
     // in that case we can only try to overwrite return value for posthooks with return value type specified explicitly
     if (!(fcc.function_handler->op_array.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || (ZEND_TYPE_PURE_MASK(fcc.function_handler->common.arg_info[-1].type) & MAY_BE_VOID)) {
-        ELOG_TRACE(EAPM_GL(logger_), "callPostHook hook doesn't explicitly specify return type other than void");
+        ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "callPostHook hook doesn't explicitly specify return type other than void");
         return;
     }
 
@@ -219,7 +219,7 @@ void callPostHook(AutoZval &hook, zval *return_value, zend_object *exception, ze
         //     return;
         // }
         bool sameType = ZEND_TYPE_CONTAINS_CODE(execute_data->func->common.arg_info[-1].type, Z_TYPE_P(hookRv.get()));
-        ELOG_DEBUG(EAPM_GL(logger_), "callPostHook hasRvType: %d, isVoid: %d sameType: %d, hookRvType: %d", execute_data->func->op_array.fn_flags & ZEND_ACC_HAS_RETURN_TYPE, static_cast<bool>(ZEND_TYPE_PURE_MASK(execute_data->func->common.arg_info[-1].type) & MAY_BE_VOID), sameType, hookRv.getType());
+        ELOGF_DEBUG(EAPM_GL(logger_), INSTRUMENTATION, "callPostHook hasRvType: %d, isVoid: %d sameType: %d, hookRvType: %d", execute_data->func->op_array.fn_flags & ZEND_ACC_HAS_RETURN_TYPE, static_cast<bool>(ZEND_TYPE_PURE_MASK(execute_data->func->common.arg_info[-1].type) & MAY_BE_VOID), sameType, hookRv.getType());
     }
 
     zval_ptr_dtor(return_value);
@@ -245,7 +245,7 @@ void ZEND_FASTCALL internal_function_handler(INTERNAL_FUNCTION_PARAMETERS) {
     auto originalHandler = InternalStorage_t::getInstance().get(hash);
     if (!originalHandler) {
         auto [cls, func] = getClassAndFunctionName(execute_data);
-        ELOG_CRITICAL(EAPM_GL(logger_), "Unable to find function handler " PRsv "::" PRsv, PRsvArg(cls), PRsvArg(func));
+        ELOGF_CRITICAL(EAPM_GL(logger_), INSTRUMENTATION, "Unable to find function handler " PRsv "::" PRsv, PRsvArg(cls), PRsvArg(func));
         return;
     }
 
@@ -257,7 +257,7 @@ void ZEND_FASTCALL internal_function_handler(INTERNAL_FUNCTION_PARAMETERS) {
     auto callbacks = reinterpret_cast<InstrumentedFunctionHooksStorage_t *>(EAPM_GL(hooksStorage_).get())->find(hash);
     if (!callbacks) {
         callOriginalHandler(originalHandler, INTERNAL_FUNCTION_PARAM_PASSTHRU);
-        ELOG_WARNING(EAPM_GL(logger_), "Unable to find function callbacks");
+        ELOGF_WARNING(EAPM_GL(logger_), INSTRUMENTATION, "Unable to find function callbacks");
         return;
     }
 
@@ -272,7 +272,7 @@ void ZEND_FASTCALL internal_function_handler(INTERNAL_FUNCTION_PARAMETERS) {
             handleAndReleaseHookException(EG(exception));
         } catch (std::exception const &e) {
             auto [cls, func] = getClassAndFunctionName(execute_data);
-            ELOG_CRITICAL(EAPM_GL(logger_), "%s hash: 0x%X " PRsv "::" PRsv, e.what(), hash, PRsvArg(cls), PRsvArg(func));
+            ELOGF_CRITICAL(EAPM_GL(logger_), INSTRUMENTATION, "%s hash: 0x%X " PRsv "::" PRsv, e.what(), hash, PRsvArg(cls), PRsvArg(func));
         }
     }
 
@@ -290,7 +290,7 @@ void ZEND_FASTCALL internal_function_handler(INTERNAL_FUNCTION_PARAMETERS) {
             handleAndReleaseHookException(EG(exception));
         } catch (std::exception const &e) {
             auto [cls, func] = getClassAndFunctionName(execute_data);
-            ELOG_CRITICAL(EAPM_GL(logger_), "%s hash: 0x%X " PRsv "::" PRsv, e.what(), hash, PRsvArg(cls), PRsvArg(func));
+            ELOGF_CRITICAL(EAPM_GL(logger_), INSTRUMENTATION, "%s hash: 0x%X " PRsv "::" PRsv, e.what(), hash, PRsvArg(cls), PRsvArg(func));
         }
     }
 
@@ -314,19 +314,19 @@ bool instrumentFunction(LoggerInterface *log, std::string_view cName, std::strin
         table = EG(function_table);
     } else {
         if (!EG(class_table)) {
-            ELOG_DEBUG(log, "instrumentFunction Class table is empty. Function " PRsv "::" PRsv " not found and cannot be instrumented.", PRsvArg(className), PRsvArg(functionName));
+            ELOGF_DEBUG(log, INSTRUMENTATION, "instrumentFunction Class table is empty. Function " PRsv "::" PRsv " not found and cannot be instrumented.", PRsvArg(className), PRsvArg(functionName));
             return false;
         }
 
         auto ce = static_cast<zend_class_entry *>(zend_hash_str_find_ptr(EG(class_table), className.data(), className.length()));
         if (!ce) {
-            ELOG_DEBUG(log, "instrumentFunction Class not found. Function " PRsv "::" PRsv " not found and cannot be instrumented.", PRsvArg(className), PRsvArg(functionName));
+            ELOGF_DEBUG(log, INSTRUMENTATION, "instrumentFunction Class not found. Function " PRsv "::" PRsv " not found and cannot be instrumented.", PRsvArg(className), PRsvArg(functionName));
 
             if (log->doesMeetsLevelCondition(logLevel_trace)) {
                 zend_string *argStrKey = nullptr;
                 ZEND_HASH_FOREACH_STR_KEY(EG(class_table), argStrKey) {
                     if (argStrKey) {
-                        ELOG_DEBUG(log, "instrumentFunction Class not found. Function " PRsv "::" PRsv " not found and cannot be instrumented. %s", PRsvArg(className), PRsvArg(functionName), ZSTR_VAL(argStrKey));
+                        ELOGF_DEBUG(log, INSTRUMENTATION, "instrumentFunction Class not found. Function " PRsv "::" PRsv " not found and cannot be instrumented. %s", PRsvArg(className), PRsvArg(functionName), ZSTR_VAL(argStrKey));
                     }
                 }
                 ZEND_HASH_FOREACH_END();
@@ -345,14 +345,14 @@ bool instrumentFunction(LoggerInterface *log, std::string_view cName, std::strin
 
    	zend_function *func = reinterpret_cast<zend_function *>(zend_hash_str_find_ptr(table, functionName.data(), functionName.length()));
     if (!func) {
-        ELOG_DEBUG(log, "instrumentFunction " PRsv "::" PRsv " not found and cannot be instrumented.", PRsvArg(className), PRsvArg(functionName));
+        ELOGF_DEBUG(log, INSTRUMENTATION, "instrumentFunction " PRsv "::" PRsv " not found and cannot be instrumented.", PRsvArg(className), PRsvArg(functionName));
         return false;
     }
 
     zend_ulong funcHash = ZSTR_HASH(func->common.function_name);
     zend_ulong hash = classHash ^ (funcHash << 1);
 
-    ELOG_DEBUG(log, "instrumentFunction 0x%X " PRsv "::" PRsv " type: %s is marked to be instrumented", hash, PRsvArg(className), PRsvArg(functionName), func->common.type == ZEND_INTERNAL_FUNCTION ? "internal" : "user");
+    ELOGF_DEBUG(log, INSTRUMENTATION, "instrumentFunction 0x%X " PRsv "::" PRsv " type: %s is marked to be instrumented", hash, PRsvArg(className), PRsvArg(functionName), func->common.type == ZEND_INTERNAL_FUNCTION ? "internal" : "user");
 
     reinterpret_cast<InstrumentedFunctionHooksStorage_t *>(EAPM_GL(hooksStorage_).get())->store(hash, AutoZval{callableOnEntry}, AutoZval{callableOnExit});
 
@@ -362,7 +362,7 @@ bool instrumentFunction(LoggerInterface *log, std::string_view cName, std::strin
             InternalStorage_t::getInstance().store(hash, func->internal_function.handler);
             func->internal_function.handler = internal_function_handler;
         }
-        ELOG_DEBUG(log, PRsv "::" PRsv " instrumented, key: 0x%X", PRsvArg(className), PRsvArg(functionName), hash);
+        ELOGF_DEBUG(log, INSTRUMENTATION, PRsv "::" PRsv " instrumented, key: 0x%X", PRsvArg(className), PRsvArg(functionName), hash);
     }
 
     return true;
@@ -372,12 +372,12 @@ bool instrumentFunction(LoggerInterface *log, std::string_view cName, std::strin
 
 void elasticObserverFcallBeginHandler(zend_execute_data *execute_data) {
     auto hash = getClassAndFunctionHashFromExecuteData(execute_data);
-    ELOG_TRACE(EAPM_GL(logger_), "elasticObserverFcallBeginHandler hash 0x%X", hash);
+    ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "elasticObserverFcallBeginHandler hash 0x%X", hash);
 
     auto callbacks = reinterpret_cast<InstrumentedFunctionHooksStorage_t *>(EAPM_GL(hooksStorage_).get())->find(hash);
     if (!callbacks) {
         auto [cls, func] = getClassAndFunctionName(execute_data);
-        ELOG_ERROR(EAPM_GL(logger_), "Unable to find prehook handler for 0x%X " PRsv "::" PRsv, hash, PRsvArg(cls), PRsvArg(func));
+        ELOGF_ERROR(EAPM_GL(logger_), INSTRUMENTATION, "Unable to find prehook handler for 0x%X " PRsv "::" PRsv, hash, PRsvArg(cls), PRsvArg(func));
         return;
     }
 
@@ -389,19 +389,19 @@ void elasticObserverFcallBeginHandler(zend_execute_data *execute_data) {
             handleAndReleaseHookException(EG(exception));
         } catch (std::exception const &e) {
             auto [cls, func] = getClassAndFunctionName(execute_data);
-            ELOG_CRITICAL(EAPM_GL(logger_), "elasticObserverFcallBeginHandler. Unable to call prehook for 0x%X " PRsv "::" PRsv ": '%s'", hash, PRsvArg(cls), PRsvArg(func), e.what());
+            ELOGF_CRITICAL(EAPM_GL(logger_), INSTRUMENTATION, "elasticObserverFcallBeginHandler. Unable to call prehook for 0x%X " PRsv "::" PRsv ": '%s'", hash, PRsvArg(cls), PRsvArg(func), e.what());
         }
     }
 }
 
 void elasticObserverFcallEndHandler(zend_execute_data *execute_data, zval *retval) {
     auto hash = getClassAndFunctionHashFromExecuteData(execute_data);
-    ELOG_TRACE(EAPM_GL(logger_), "elasticObserverFcallEndHandler hash 0x%X", hash);
+    ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "elasticObserverFcallEndHandler hash 0x%X", hash);
 
     auto callbacks = reinterpret_cast<InstrumentedFunctionHooksStorage_t *>(EAPM_GL(hooksStorage_).get())->find(hash);
     if (!callbacks) {
         auto [cls, func] = getClassAndFunctionName(execute_data);
-        ELOG_ERROR(EAPM_GL(logger_), "Unable to find posthook handler for 0x%X " PRsv "::" PRsv, hash, PRsvArg(cls), PRsvArg(func));
+        ELOGF_ERROR(EAPM_GL(logger_), INSTRUMENTATION, "Unable to find posthook handler for 0x%X " PRsv "::" PRsv, hash, PRsvArg(cls), PRsvArg(func));
         return;
     }
 
@@ -412,7 +412,7 @@ void elasticObserverFcallEndHandler(zend_execute_data *execute_data, zval *retva
             handleAndReleaseHookException(EG(exception));
         } catch (std::exception const &e) {
             auto [cls, func] = getClassAndFunctionName(execute_data);
-            ELOG_CRITICAL(EAPM_GL(logger_), "elasticObserverFcallEndHandler. Unable to call posthook for 0x%X " PRsv "::" PRsv ": '%s'", hash, PRsvArg(cls), PRsvArg(func), e.what());
+            ELOGF_CRITICAL(EAPM_GL(logger_), INSTRUMENTATION, "elasticObserverFcallEndHandler. Unable to call posthook for 0x%X " PRsv "::" PRsv ": '%s'", hash, PRsvArg(cls), PRsvArg(func), e.what());
         }
     }
 }
@@ -424,7 +424,7 @@ zend_observer_fcall_handlers elasticRegisterObserver(zend_execute_data *execute_
 
     auto hash = getClassAndFunctionHashFromExecuteData(execute_data);
     if (hash == 0) {
-        ELOG_TRACE(EAPM_GL(logger_), "elasticRegisterObserver main scope");
+        ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "elasticRegisterObserver main scope");
         return {nullptr, nullptr};
     }
 
@@ -432,7 +432,7 @@ zend_observer_fcall_handlers elasticRegisterObserver(zend_execute_data *execute_
     if (!callbacks) {
         if (EAPM_GL(logger_)->doesMeetsLevelCondition(LogLevel::logLevel_trace)) {
             auto [cls, func] = getClassAndFunctionName(execute_data);
-            ELOG_TRACE(EAPM_GL(logger_), "elasticRegisterObserver hash: 0x%X " PRsv "::" PRsv ", not marked to be instrumented", hash, PRsvArg(cls), PRsvArg(func));
+            ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "elasticRegisterObserver hash: 0x%X " PRsv "::" PRsv ", not marked to be instrumented", hash, PRsvArg(cls), PRsvArg(func));
         }
 
         auto ce = execute_data->func->common.scope;
@@ -450,7 +450,7 @@ zend_observer_fcall_handlers elasticRegisterObserver(zend_execute_data *execute_
             if (callbacks) {
                 if (EAPM_GL(logger_)->doesMeetsLevelCondition(LogLevel::logLevel_trace)) {
                     auto [cls, func] = getClassAndFunctionName(execute_data);
-                    ELOG_TRACE(EAPM_GL(logger_), "elasticRegisterObserver hash: 0x%X " PRsv "::" PRsv ", will be instrumented because interface 0x%X '" PRsv "' was marked to be instrumented", hash, PRsvArg(cls), PRsvArg(func), ifaceHash, PRzsArg(ce->interfaces[i]->name));
+                    ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "elasticRegisterObserver hash: 0x%X " PRsv "::" PRsv ", will be instrumented because interface 0x%X '" PRsv "' was marked to be instrumented", hash, PRsvArg(cls), PRsvArg(func), ifaceHash, PRzsArg(ce->interfaces[i]->name));
                 }
                 // copy callbacks from interface storage hash to implementation hash
                 for (auto &item : *callbacks) {
@@ -478,7 +478,7 @@ zend_observer_fcall_handlers elasticRegisterObserver(zend_execute_data *execute_
             break;
         }
     }
-    ELOG_TRACE(EAPM_GL(logger_), "elasticRegisterObserver hash: 0x%X, havePreHooks: %d havePostHooks: %d", hash, havePreHook, havePostHook);
+    ELOGF_TRACE(EAPM_GL(logger_), INSTRUMENTATION, "elasticRegisterObserver hash: 0x%X, havePreHooks: %d havePostHooks: %d", hash, havePreHook, havePostHook);
 
     return {havePreHook ? elasticObserverFcallBeginHandler : nullptr, havePostHook ? elasticObserverFcallEndHandler : nullptr};
 }
diff --git a/prod/native/extension/code/ModuleEntry.cpp b/prod/native/extension/code/ModuleEntry.cpp
index e929f39..d1e7f35 100644
--- a/prod/native/extension/code/ModuleEntry.cpp
+++ b/prod/native/extension/code/ModuleEntry.cpp
@@ -95,7 +95,7 @@ static PHP_GINIT_FUNCTION(elastic_otel) {
 
     configManager.attachLogger(logger);
 
-    ELOG_DEBUG(logger, "%s: GINIT called; parent PID: %d", __FUNCTION__, static_cast<int>(elasticapm::osutils::getParentProcessId()));
+    ELOGF_DEBUG(logger, MODULE, "%s: GINIT called; parent PID: %d", __FUNCTION__, static_cast<int>(elasticapm::osutils::getParentProcessId()));
     elastic_otel_globals->globals = nullptr;
 
     auto phpBridge = std::make_shared<elasticapm::php::PhpBridge>(logger);
@@ -105,7 +105,7 @@ static PHP_GINIT_FUNCTION(elastic_otel) {
     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); });
     } catch (std::exception const &e) {
-        ELOG_CRITICAL(logger, "Unable to allocate AgentGlobals. '%s'", e.what());
+        ELOGF_CRITICAL(logger, MODULE, "Unable to allocate AgentGlobals. '%s'", e.what());
     }
 
     // ZVAL_UNDEF(&elastic_otel_globals->lastException);
@@ -115,7 +115,7 @@ static PHP_GINIT_FUNCTION(elastic_otel) {
 
 PHP_GSHUTDOWN_FUNCTION(elastic_otel) {
     if (elastic_otel_globals->globals) {
-        ELOG_DEBUG(elastic_otel_globals->globals->logger_, "%s: GSHUTDOWN called; parent PID: %d", __FUNCTION__, static_cast<int>(elasticapm::osutils::getParentProcessId()) );
+        ELOGF_DEBUG(elastic_otel_globals->globals->logger_, MODULE, "%s: GSHUTDOWN called; parent PID: %d", __FUNCTION__, static_cast<int>(elasticapm::osutils::getParentProcessId()));
         delete elastic_otel_globals->globals;
     }
 
@@ -154,7 +154,7 @@ PHP_MINIT_FUNCTION(elastic_otel) {
     elasticApmModuleInit(type, module_number);
 
     if (!zend_register_internal_module(&elastic_otel_fake)) {
-        ELOG_WARNING(ELASTICAPM_G(globals)->logger_, "Unable to create artificial opentelemetry extension. There might be stability issues.");
+        ELOGF_WARNING(ELASTICAPM_G(globals)->logger_, MODULE, "Unable to create artificial opentelemetry extension. There might be stability issues.");
     }
 
     return SUCCESS;
diff --git a/prod/native/extension/code/ModuleFunctions.cpp b/prod/native/extension/code/ModuleFunctions.cpp
index 3d3da0c..6388ea4 100644
--- a/prod/native/extension/code/ModuleFunctions.cpp
+++ b/prod/native/extension/code/ModuleFunctions.cpp
@@ -103,6 +103,59 @@ PHP_FUNCTION(elastic_otel_log) {
 }
 /* }}} */
 
+ZEND_BEGIN_ARG_INFO_EX(elastic_otel_logf_arginfo, /* _unused: */ 0, /* return_reference: */ 0, /* required_num_args: */ 7)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, isForced, IS_LONG, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, level, IS_LONG, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, feature, IS_LONG, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, category, IS_STRING, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, file, IS_STRING, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, line, IS_LONG, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, func, IS_STRING, /* allow_null: */ 0)
+ZEND_ARG_TYPE_INFO(/* pass_by_ref: */ 0, message, IS_STRING, /* allow_null: */ 0)
+ZEND_END_ARG_INFO()
+
+/* {{{ elastic_otel_logf(
+ *      int $isForced,
+ *      int $level,
+ *      int $feature,
+ *      string $category,
+ *      string $file,
+ *      int $line,
+ *      string $func,
+ *      string $message
+ *  ): void
+ */
+PHP_FUNCTION(elastic_otel_log_feature) {
+    zend_long isForced = 0;
+    zend_long level = 0;
+    zend_long feature = 0;
+    char *file = nullptr;
+    size_t fileLength = 0;
+    char *category = nullptr;
+    size_t categoryLength = 0;
+    zend_long line = 0;
+    char *func = nullptr;
+    size_t funcLength = 0;
+    char *message = nullptr;
+    size_t messageLength = 0;
+
+    ZEND_PARSE_PARAMETERS_START(/* min_num_args: */ 8, /* max_num_args: */ 8)
+    Z_PARAM_LONG(isForced)
+    Z_PARAM_LONG(level)
+    Z_PARAM_LONG(feature)
+    Z_PARAM_STRING(category, categoryLength)
+    Z_PARAM_STRING(file, fileLength)
+    Z_PARAM_LONG(line)
+    Z_PARAM_STRING(func, funcLength)
+    Z_PARAM_STRING(message, messageLength)
+    ZEND_PARSE_PARAMETERS_END();
+
+    if (ELASTICAPM_G(globals)->logger_->doesFeatureMeetsLevelCondition(static_cast<LogLevel>(level), static_cast<elasticapm::php::LogFeature>(feature))) {
+        ELASTICAPM_G(globals)->logger_->printf(static_cast<LogLevel>(level), PRsv " " PRsv " %d " PRsv " " PRsv, PRcsvArg(category, categoryLength), PRcsvArg(file, fileLength), line, PRcsvArg(func, funcLength), PRcsvArg(message, messageLength));
+    }
+}
+/* }}} */
+
 ZEND_BEGIN_ARG_INFO_EX(elastic_otel_get_last_thrown_arginfo, /* _unused */ 0, /* return_reference: */ 0, /* required_num_args: */ 0)
 ZEND_END_ARG_INFO()
 /* {{{ elastic_otel_get_last_thrown(): mixed
@@ -152,7 +205,7 @@ PHP_FUNCTION(elastic_otel_hook) {
     std::string_view functionName = function_name ? std::string_view{ZSTR_VAL(function_name), ZSTR_LEN(function_name)} : std::string_view{};
 
     // if (!EAPM_GL(requestScope_)->isFunctional()) {
-    //     ELOG_DEBUG(EAPM_GL(logger_), "elastic_otel_hook. Can't instrument " PRsv "::" PRsv " beacuse agent is not functional.", PRsvArg(className), PRsvArg(functionName));
+    //     ELOGF_DEBUG(EAPM_GL(logger_), MODULE, "elastic_otel_hook. Can't instrument " PRsv "::" PRsv " beacuse agent is not functional.", PRsvArg(className), PRsvArg(functionName));
     //     RETURN_BOOL(false);
     //     return;
     // }
@@ -222,6 +275,7 @@ const zend_function_entry elastic_otel_functions[] = {
     PHP_FE( elastic_otel_is_enabled, elastic_otel_no_paramters_arginfo )
     PHP_FE( elastic_otel_get_config_option_by_name, elastic_otel_get_config_option_by_name_arginfo )
     PHP_FE( elastic_otel_log, elastic_otel_log_arginfo )
+    PHP_FE( elastic_otel_log_feature, elastic_otel_logf_arginfo )
     PHP_FE( elastic_otel_get_last_thrown, elastic_otel_get_last_thrown_arginfo )
     PHP_FE( elastic_otel_get_last_php_error, elastic_otel_get_last_php_error_arginfo )
     PHP_FE( elastic_otel_hook, elastic_otel_hook_arginfo )
diff --git a/prod/native/extension/code/ModuleIniEntries.cpp b/prod/native/extension/code/ModuleIniEntries.cpp
index 9f100fd..78d517d 100644
--- a/prod/native/extension/code/ModuleIniEntries.cpp
+++ b/prod/native/extension/code/ModuleIniEntries.cpp
@@ -97,7 +97,7 @@ bool registerElasticApmIniEntries(elasticapm::php::LoggerInterface *log, int mod
         auto iniName = elasticapm::utils::getIniName(option.first);
 
         if (zend_ini_register_displayer(iniName.data(), iniName.length(), displaySecretIniValue) != ZEND_RESULT_CODE::SUCCESS) {
-            ELOG_WARNING(log, "zend_ini_register_displayer() failed; iniName: " PRsv, PRsvArg(iniName));
+            ELOGF_WARNING(log, MODULE, "zend_ini_register_displayer() failed; iniName: " PRsv, PRsvArg(iniName));
         }
 
     }
diff --git a/prod/native/extension/code/ModuleInit.cpp b/prod/native/extension/code/ModuleInit.cpp
index aae482c..723054b 100644
--- a/prod/native/extension/code/ModuleInit.cpp
+++ b/prod/native/extension/code/ModuleInit.cpp
@@ -69,7 +69,7 @@ void elasticApmModuleInit(int moduleType, int moduleNumber) {
     configManager.update();
     globals->config_->update();
 
-    ELOG_DEBUG(globals->logger_, "%s entered: moduleType: %d, moduleNumber: %d, parent PID: %d, SAPI: %s (%d) is %s", __FUNCTION__, moduleType, moduleNumber, static_cast<int>(elasticapm::osutils::getParentProcessId()), sapi.getName().data(), static_cast<uint8_t>(sapi.getType()), sapi.isSupported() ? "supported" : "unsupported");
+    ELOGF_DEBUG(globals->logger_, MODULE, "%s entered: moduleType: %d, moduleNumber: %d, parent PID: %d, SAPI: %s (%d) is %s", __FUNCTION__, moduleType, moduleNumber, static_cast<int>(elasticapm::osutils::getParentProcessId()), sapi.getName().data(), static_cast<uint8_t>(sapi.getType()), sapi.isSupported() ? "supported" : "unsupported");
     if (!sapi.isSupported()) {
         return;
     }
@@ -83,11 +83,11 @@ void elasticApmModuleInit(int moduleType, int moduleNumber) {
     logStartupPreamble(globals->logger_.get());
 
     if (!EAPM_CFG(enabled)) {
-        ELOG_INFO(globals->logger_, "Extension is disabled");
+        ELOGF_INFO(globals->logger_, MODULE, "Extension is disabled");
         return;
     }
 
-    ELOG_DEBUG(globals->logger_, "MINIT Replacing hooks");
+    ELOGF_DEBUG(globals->logger_, MODULE, "MINIT Replacing hooks");
     elasticapm::php::Hooking::getInstance().replaceHooks();
 
     zend_observer_activate();
@@ -95,7 +95,7 @@ void elasticApmModuleInit(int moduleType, int moduleNumber) {
 
 
     if (php_check_open_basedir_ex(EAPM_GL(config_)->get(&elasticapm::php::ConfigurationSnapshot::bootstrap_php_part_file).c_str(), false) != 0) {
-        ELOG_WARNING(globals->logger_, "Elastic Agent bootstrap file (%s) is located outside of paths allowed by open_basedir ini setting. Read more details here https://www.elastic.co/guide/en/apm/agent/php/current/setup.html#limitations", EAPM_GL(config_)->get(&elasticapm::php::ConfigurationSnapshot::bootstrap_php_part_file).c_str());
+        ELOGF_WARNING(globals->logger_, MODULE, "Elastic Agent bootstrap file (%s) is located outside of paths allowed by open_basedir ini setting. Read more details here https://www.elastic.co/guide/en/apm/agent/php/current/setup.html#limitations", EAPM_GL(config_)->get(&elasticapm::php::ConfigurationSnapshot::bootstrap_php_part_file).c_str());
     }
 }
 
diff --git a/prod/native/libcommon/code/AgentGlobals.cpp b/prod/native/libcommon/code/AgentGlobals.cpp
index cfd669b..4377363 100644
--- a/prod/native/libcommon/code/AgentGlobals.cpp
+++ b/prod/native/libcommon/code/AgentGlobals.cpp
@@ -30,6 +30,8 @@
 #include "CommonUtils.h"
 #include "transport/HttpTransportAsync.h"
 
+#include "LogFeature.h"
+
 namespace elasticapm::php {
 // clang-format off
 
@@ -53,18 +55,19 @@ AgentGlobals::AgentGlobals(std::shared_ptr<LoggerInterface> logger,
     logSinkSysLog_(std::move(logSinkSysLog)),
     logSinkFile_(std::move(logSinkFile))
     {
-        config_->addConfigUpdateWatcher([stderrsink = logSinkStdErr_, syslogsink = logSinkSysLog_, filesink = logSinkFile_](ConfigurationSnapshot const &cfg) {
+        config_->addConfigUpdateWatcher([logger = logger_, stderrsink = logSinkStdErr_, syslogsink = logSinkSysLog_, filesink = logSinkFile_](ConfigurationSnapshot const &cfg) {
             stderrsink->setLevel(cfg.log_level_stderr);
             syslogsink->setLevel(cfg.log_level_syslog);
             if (filesink) {
                 if (cfg.log_file.empty()) {
                     filesink->setLevel(LogLevel::logLevel_off);
-                    return;
+                } else {
+                    filesink->setLevel(cfg.log_level_file);
+                    filesink->reopen(utils::getParameterizedString(cfg.log_file));
                 }
-
-                filesink->setLevel(cfg.log_level_file);
-                filesink->reopen(utils::getParameterizedString(cfg.log_file));
             }
+
+            logger->setLogFeatures(utils::parseLogFeatures(logger, cfg.log_features));
         });
     }
 
diff --git a/prod/native/libcommon/code/CMakeLists.txt b/prod/native/libcommon/code/CMakeLists.txt
index 16b38c5..51e17be 100644
--- a/prod/native/libcommon/code/CMakeLists.txt
+++ b/prod/native/libcommon/code/CMakeLists.txt
@@ -17,10 +17,13 @@ target_link_libraries(${_Target}
 )
 
 configure_file("elastic_otel_version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/generated/elastic_otel_version.h")
+configure_file("LogFeature.h.in" "${CMAKE_CURRENT_BINARY_DIR}/generated/LogFeature.h")
+
 
 target_include_directories(${_Target} PUBLIC "./"
                                             "${Boost_INCLUDE_DIRS}"
                                             "${LIBUNWIND_INCLUDE_DIRS}"
+                                            "${magic_enum_INCLUDE_DIRS}"
                                             "${CMAKE_CURRENT_BINARY_DIR}/generated/"
                                             Boost::headers
                                             )
diff --git a/prod/native/libcommon/code/CommonUtils.cpp b/prod/native/libcommon/code/CommonUtils.cpp
index 4fa28ba..94d8d7c 100644
--- a/prod/native/libcommon/code/CommonUtils.cpp
+++ b/prod/native/libcommon/code/CommonUtils.cpp
@@ -21,13 +21,17 @@
 #include "CommonUtils.h"
 #include "CiCharTraits.h"
 #include "LogLevel.h"
+#include "LogFeature.h"
+#include "LoggerInterface.h"
 
 #include <algorithm>
 #include <array>
 #include <charconv>
 #include <chrono>
 #include <cstdarg>
+#include <memory>
 #include <optional>
+#include <ranges>
 #include <string_view>
 #include <signal.h>
 #include <stddef.h>
@@ -259,4 +263,32 @@ std::optional<std::string> getConnectionDetailsFromURL(std::string const &url) {
 
     return std::nullopt;
 }
+
+// FEATURENAME=LEVEL,ANOTHERFEATURE=LOGLEVEL
+std::unordered_map<elasticapm::php::LogFeature, LogLevel> parseLogFeatures(std::shared_ptr<elasticapm::php::LoggerInterface> logger, std::string_view logFeatures) {
+    std::unordered_map<elasticapm::php::LogFeature, LogLevel> features;
+
+    if (!logFeatures.empty()) {
+        using namespace std::string_view_literals;
+        for (const auto split : std::views::split(logFeatures, ","sv)) {
+            std::string_view featureAndValue(split);
+            auto pos = featureAndValue.find('=');
+            if (pos != std::string_view::npos) {
+                std::string_view option = featureAndValue.substr(0, pos);
+                std::string_view value = featureAndValue.substr(pos + 1);
+
+                try {
+                    auto level = parseLogLevel(value);
+                    auto feature = elasticapm::php::parseLogFeature(option);
+                    features.emplace(feature, level);
+                } catch (std::invalid_argument const &e) {
+                    ELOG_WARNING(logger, "Error while parsing LogFeature " PRsv ", exception: %s ", PRsvArg(featureAndValue), e.what());
+                }
+            } else {
+                ELOG_WARNING(logger, "Error while parsing LogFeature " PRsv, PRsvArg(featureAndValue));
+            }
+        }
+    }
+    return features;
+}
 }
\ No newline at end of file
diff --git a/prod/native/libcommon/code/CommonUtils.h b/prod/native/libcommon/code/CommonUtils.h
index 7c19d60..f9d699c 100644
--- a/prod/native/libcommon/code/CommonUtils.h
+++ b/prod/native/libcommon/code/CommonUtils.h
@@ -20,12 +20,17 @@
 
 #pragma once
 
+#include "LoggerInterface.h"
+#include "LogFeature.h"
 #include "LogLevel.h"
+
 #include <chrono>
+#include <memory>
 #include <optional>
 #include <regex>
 #include <string>
 #include <string_view>
+#include <unordered_map>
 
 namespace elasticapm::utils {
 
@@ -74,4 +79,6 @@ struct ParsedURL {
 std::optional<ParsedURL> parseUrl(std::string const &url);
 
 std::optional<std::string> getConnectionDetailsFromURL(std::string const &url);
+
+std::unordered_map<elasticapm::php::LogFeature, LogLevel> parseLogFeatures(std::shared_ptr<elasticapm::php::LoggerInterface> logger, std::string_view logFeatures);
 }
\ No newline at end of file
diff --git a/prod/native/libcommon/code/ConfigurationManager.h b/prod/native/libcommon/code/ConfigurationManager.h
index 4dcf6d2..5e97b22 100644
--- a/prod/native/libcommon/code/ConfigurationManager.h
+++ b/prod/native/libcommon/code/ConfigurationManager.h
@@ -106,6 +106,7 @@ class ConfigurationManager {
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_FILE, OptionMetadata::type::loglevel, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_STDERR, OptionMetadata::type::loglevel, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_SYSLOG, OptionMetadata::type::loglevel, false),
+        BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_LOG_FEATURES, OptionMetadata::type::string, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_DIAGNOSTICS_FILE, OptionMetadata::type::string, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_VERIFY_SERVER_CERT, OptionMetadata::type::boolean, false),
         BUILD_METADATA(ELASTIC_OTEL_CFG_OPT_NAME_MAX_SEND_QUEUE_SIZE, OptionMetadata::type::bytes, false),
diff --git a/prod/native/libcommon/code/ConfigurationSnapshot.h b/prod/native/libcommon/code/ConfigurationSnapshot.h
index 3db9e17..cac62f7 100644
--- a/prod/native/libcommon/code/ConfigurationSnapshot.h
+++ b/prod/native/libcommon/code/ConfigurationSnapshot.h
@@ -31,6 +31,7 @@
 #define ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_FILE log_level_file
 #define ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_STDERR log_level_stderr
 #define ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_SYSLOG log_level_syslog
+#define ELASTIC_OTEL_CFG_OPT_NAME_LOG_FEATURES log_features
 #define ELASTIC_OTEL_CFG_OPT_NAME_VERIFY_SERVER_CERT verify_server_cert
 #define ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_DIAGNOSTICS_FILE debug_diagnostic_file
 #define ELASTIC_OTEL_CFG_OPT_NAME_MAX_SEND_QUEUE_SIZE max_send_queue_size
@@ -49,6 +50,7 @@ struct ConfigurationSnapshot {
     LogLevel ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_FILE = LogLevel::logLevel_off;
     LogLevel ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_STDERR = LogLevel::logLevel_off;
     LogLevel ELASTIC_OTEL_CFG_OPT_NAME_LOG_LEVEL_SYSLOG = LogLevel::logLevel_off;
+    std::string ELASTIC_OTEL_CFG_OPT_NAME_LOG_FEATURES;
     std::string ELASTIC_OTEL_CFG_OPT_NAME_DEBUG_DIAGNOSTICS_FILE;
     bool ELASTIC_OTEL_CFG_OPT_NAME_VERIFY_SERVER_CERT = true;
     std::size_t ELASTIC_OTEL_CFG_OPT_NAME_MAX_SEND_QUEUE_SIZE = 2 * 1024 * 1204;
diff --git a/prod/native/libcommon/code/LogFeature.cpp b/prod/native/libcommon/code/LogFeature.cpp
new file mode 100644
index 0000000..2e93399
--- /dev/null
+++ b/prod/native/libcommon/code/LogFeature.cpp
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#include "LogFeature.h"
+#include <magic_enum.hpp>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+namespace elasticapm::php {
+
+[[nodiscard]] LogFeature parseLogFeature(std::string_view featureName) {
+    using namespace std::string_literals;
+    auto feature = magic_enum::enum_cast<LogFeature>(featureName, magic_enum::case_insensitive);
+    if (!feature.has_value()) {
+        throw std::invalid_argument("Unknown log feature: "s + std::string(featureName));
+    }
+    return feature.value();
+}
+
+} // namespace elasticapm::php
diff --git a/prod/native/libcommon/code/LogFeature.h.in b/prod/native/libcommon/code/LogFeature.h.in
new file mode 100644
index 0000000..963e98d
--- /dev/null
+++ b/prod/native/libcommon/code/LogFeature.h.in
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+/* This file has been generated, do not edit it manually.
+ * If you want to make changes, edit the file LogFeature.h.in
+ * in the sources tree.
+ * Remember, every time you add a new feature to the properties,
+ * reconfigure the project and regenerate the files for PHP as well
+ */
+
+#pragma once
+
+#include <string_view>
+
+namespace elasticapm::php {
+
+// clang-format off
+enum LogFeature {
+    @_PROJECT_PROPERTIES_LOGGER_FEATURES_ENUM_VALUES@
+};
+// clang-format on
+
+[[nodiscard]] LogFeature parseLogFeature(std::string_view featureName);
+
+} // namespace elasticapm::php
\ No newline at end of file
diff --git a/prod/native/libcommon/code/Logger.cpp b/prod/native/libcommon/code/Logger.cpp
index 8e8aeb7..a2a7b2c 100644
--- a/prod/native/libcommon/code/Logger.cpp
+++ b/prod/native/libcommon/code/Logger.cpp
@@ -27,6 +27,30 @@
 
 namespace elasticapm::php {
 
+void Logger::setLogFeatures(std::unordered_map<elasticapm::php::LogFeature, LogLevel> features) {
+    features_ = std::move(features);
+}
+
+bool Logger::doesFeatureMeetsLevelCondition(LogLevel level, LogFeature feature) const {
+    if (features_.empty()) {
+        return doesMeetsLevelCondition(level);
+    }
+
+    {
+        auto found = features_.find(feature);
+        if (found != std::end(features_)) {
+            return level <= found->second;
+        }
+    }
+
+    auto found = features_.find(LogFeature::ALL);
+    if (found != std::end(features_)) {
+        return level <= found->second;
+    }
+
+    return false;
+}
+
 LogLevel Logger::getMaxLogLevel() const {
     auto maxLevel = LogLevel::logLevel_off;
     for (auto const &sink : sinks_) {
diff --git a/prod/native/libcommon/code/Logger.h b/prod/native/libcommon/code/Logger.h
index 4f9cffe..5d58d39 100644
--- a/prod/native/libcommon/code/Logger.h
+++ b/prod/native/libcommon/code/Logger.h
@@ -21,6 +21,7 @@
 
 #include "LoggerInterface.h"
 #include "LoggerSinkInterface.h"
+#include "LogFeature.h"
 #include "CommonUtils.h"
 #include "SpinLock.h"
 
@@ -70,16 +71,21 @@ class Logger : public LoggerInterface {
     }
 
     void printf(LogLevel level, const char *format, ...) const override;
+
     bool doesMeetsLevelCondition(LogLevel level) const override;
+    bool doesFeatureMeetsLevelCondition(LogLevel level, LogFeature feature) const override;
 
     void attachSink(std::shared_ptr<LoggerSinkInterface> sink);
 
     LogLevel getMaxLogLevel() const override;
 
+    void setLogFeatures(std::unordered_map<elasticapm::php::LogFeature, LogLevel> features) override;
+
 private:
     std::string getFormattedTime() const;
     std::string getFormattedProcessData() const;
     std::vector<std::shared_ptr<LoggerSinkInterface>> sinks_;
+    std::unordered_map<elasticapm::php::LogFeature, LogLevel> features_;
     mutable SpinLock spinLock_;
 };
 }
diff --git a/prod/native/libcommon/code/LoggerInterface.h b/prod/native/libcommon/code/LoggerInterface.h
index 18f2698..d0677c8 100644
--- a/prod/native/libcommon/code/LoggerInterface.h
+++ b/prod/native/libcommon/code/LoggerInterface.h
@@ -20,7 +20,9 @@
 #pragma once
 
 #include "LogLevel.h"
+#include "LogFeature.h"
 
+#include <unordered_map>
 #include <stdarg.h>
 
 namespace elasticapm::php {
@@ -32,21 +34,34 @@ class LoggerInterface {
 
     virtual void printf(LogLevel level, const char *format, ...) const = 0;
     virtual bool doesMeetsLevelCondition(LogLevel level) const = 0;
+    virtual bool doesFeatureMeetsLevelCondition(LogLevel level, LogFeature feature) const = 0;
     virtual LogLevel getMaxLogLevel() const = 0;
+    virtual void setLogFeatures(std::unordered_map<elasticapm::php::LogFeature, LogLevel> features) = 0;
 };
 
-
 #define PRsv "%.*s"
-#define PRsvArg(strv) static_cast<int>(strv.length()), strv.data()
+#define PRsvArg(strv) static_cast<int>(strv.size()), strv.data()
 #define PRcsvArg(str, len) len, str
 #define PRzsArg(strv) ZSTR_LEN(strv), ZSTR_VAL(strv)
 
-#define ELOG_CRITICAL(logger, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(LogLevel::logLevel_critical)) break; logger->printf(LogLevel::logLevel_critical, format, ##__VA_ARGS__); } while(false);
-#define ELOG_ERROR(logger, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(LogLevel::logLevel_error)) break; logger->printf(LogLevel::logLevel_error, format, ##__VA_ARGS__); } while(false);
-#define ELOG_WARNING(logger, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(LogLevel::logLevel_warning)) break; logger->printf(LogLevel::logLevel_warning, format, ##__VA_ARGS__); } while(false);
-#define ELOG_INFO(logger, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(LogLevel::logLevel_info)) break; logger->printf(LogLevel::logLevel_info, format, ##__VA_ARGS__); } while(false);
-#define ELOG_DEBUG(logger, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(LogLevel::logLevel_debug)) break; logger->printf(LogLevel::logLevel_debug, format, ##__VA_ARGS__); } while(false);
-#define ELOG_TRACE(logger, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(LogLevel::logLevel_trace)) break; logger->printf(LogLevel::logLevel_trace, format, ##__VA_ARGS__); } while(false);
-#define ELOG(logger, level, format, ...) do { if (!logger || !logger->doesMeetsLevelCondition(level)) break; logger->printf(level, format, ##__VA_ARGS__); } while(false);
+// clang-format off
+
+#define ELOGF(logger, level, feature, format, ...) do { if (!logger || !logger->doesFeatureMeetsLevelCondition(level, elasticapm::php::LogFeature::feature)) break; logger->printf(level, format, ##__VA_ARGS__); } while(false);
+#define ELOG(logger, level,  format, ...) ELOGF(logger, level, ALL, format, ##__VA_ARGS__)
+
+#define ELOGF_CRITICAL(logger, feature, format, ...) ELOGF(logger, LogLevel::logLevel_critical, feature, format, ##__VA_ARGS__)
+#define ELOGF_ERROR(logger, feature, format, ...)    ELOGF(logger, LogLevel::logLevel_error, feature, format, ##__VA_ARGS__)
+#define ELOGF_WARNING(logger, feature, format, ...)  ELOGF(logger, LogLevel::logLevel_warning, feature, format, ##__VA_ARGS__)
+#define ELOGF_INFO(logger, feature, format, ...)     ELOGF(logger, LogLevel::logLevel_info, feature, format, ##__VA_ARGS__)
+#define ELOGF_DEBUG(logger, feature, format, ...)    ELOGF(logger, LogLevel::logLevel_debug, feature, format, ##__VA_ARGS__)
+#define ELOGF_TRACE(logger, feature, format, ...)    ELOGF(logger, LogLevel::logLevel_trace, feature, format, ##__VA_ARGS__)
+
+#define ELOG_CRITICAL(logger, format, ...) ELOG(logger, LogLevel::logLevel_critical, format, ##__VA_ARGS__)
+#define ELOG_ERROR(logger, format, ...)    ELOG(logger, LogLevel::logLevel_error, format, ##__VA_ARGS__)
+#define ELOG_WARNING(logger, format, ...)  ELOG(logger, LogLevel::logLevel_warning, format, ##__VA_ARGS__)
+#define ELOG_INFO(logger, format, ...)     ELOG(logger, LogLevel::logLevel_info, format, ##__VA_ARGS__)
+#define ELOG_DEBUG(logger, format, ...)    ELOG(logger, LogLevel::logLevel_debug, format, ##__VA_ARGS__)
+#define ELOG_TRACE(logger, format, ...)    ELOG(logger, LogLevel::logLevel_trace, format, ##__VA_ARGS__)
 
+// clang-format on
 }
diff --git a/prod/native/libcommon/code/RequestScope.h b/prod/native/libcommon/code/RequestScope.h
index 9589a67..cd0b5b4 100644
--- a/prod/native/libcommon/code/RequestScope.h
+++ b/prod/native/libcommon/code/RequestScope.h
@@ -40,19 +40,19 @@ class RequestScope {
     }
 
     void onRequestInit() {
-        ELOG_DEBUG(log_, __FUNCTION__);
+        ELOGF_DEBUG(log_, REQUEST, __FUNCTION__);
 
         resetRequest();
 
         if (!sapi_->isSupported()) {
-            ELOG_DEBUG(log_, "SAPI '%s' not supported", sapi_->getName().data());
+            ELOGF_DEBUG(log_, REQUEST, "SAPI '%s' not supported", sapi_->getName().data());
             return;
         }
 
         config_->update();
 
         if (!(*config_)->enabled) {
-            ELOG_DEBUG(log_, "Global instrumentation not enabled");
+            ELOGF_DEBUG(log_, REQUEST, "Global instrumentation not enabled");
             return;
         }
 
@@ -65,7 +65,7 @@ class RequestScope {
         preloadDetected_ = requestCounter_ == 1 ? bridge_->detectOpcachePreload() : false;
 
         if (requestCounter_ == 1 && preloadDetected_) {
-            ELOG_DEBUG(log_, "opcache.preload request detected on init");
+            ELOGF_DEBUG(log_, REQUEST, "opcache.preload request detected on init");
             return;
         } else if (!preloadDetected_ && requestCounter_ <= 2) {
             auto const &diagnosticFile = (*config_)->debug_diagnostic_file;
@@ -75,14 +75,14 @@ class RequestScope {
                         // TODO log supportability info
                         elasticapm::utils::storeDiagnosticInformation(elasticapm::utils::getParameterizedString(diagnosticFile), *(bridge_));
                     } catch (std::exception const &e) {
-                        ELOG_WARNING(log_, "Unable to write agent diagnostics: %s", e.what());
+                        ELOGF_WARNING(log_, REQUEST, "Unable to write agent diagnostics: %s", e.what());
                     }
                 }
             }
         }
 
         if (!bridge_->isScriptRestricedByOpcacheAPI() && bridge_->detectOpcacheRestartPending()) {
-            ELOG_WARNING(log_, "Detected that opcache reset is in a pending state. Instrumentation has been disabled for this request. There may be warnings or errors logged for this request.");
+            ELOGF_WARNING(log_, REQUEST, "Detected that opcache reset is in a pending state. Instrumentation has been disabled for this request. There may be warnings or errors logged for this request.");
             return;
         }
 
@@ -91,25 +91,25 @@ class RequestScope {
     }
 
     void onRequestShutdown() {
-        ELOG_DEBUG(log_, __FUNCTION__);
+        ELOGF_DEBUG(log_, REQUEST, __FUNCTION__);
 
         if (preloadDetected_) {
-            ELOG_DEBUG(log_, "opcache.preload request detected on shutdown");
+            ELOGF_DEBUG(log_, REQUEST, "opcache.preload request detected on shutdown");
             return;
         }
 
         if (!bootstrapSuccessfull_) {
-            ELOG_DEBUG(log_, "onRequestShutdown bootstrap not successfull");
+            ELOGF_DEBUG(log_, REQUEST, "onRequestShutdown bootstrap not successfull");
             return;
         }
 
         if (!bridge_->callPHPSideExitPoint()) {
-            ELOG_ERROR(log_, "callPHPSideExitPoint failed");
+            ELOGF_ERROR(log_, REQUEST, "callPHPSideExitPoint failed");
         }
     }
 
     void onRequestPostDeactivate() {
-        ELOG_DEBUG(log_, __FUNCTION__);
+        ELOGF_DEBUG(log_, REQUEST, __FUNCTION__);
 
         resetRequest();
 
@@ -119,7 +119,7 @@ class RequestScope {
     }
 
     bool handleError(int type, std::string_view errorFilename, uint32_t errorLineno, std::string_view message) {
-        ELOG_DEBUG(log_, "RequestScope::handleError type: %d fn: %s:%d msg: %s", type, errorFilename.data(), errorLineno, message.data());
+        ELOGF_DEBUG(log_, REQUEST, "RequestScope::handleError type: %d fn: %s:%d msg: %s", type, errorFilename.data(), errorLineno, message.data());
 
         bridge_->callPHPSideErrorHandler(type, errorFilename, errorLineno, message);
 
@@ -137,7 +137,7 @@ class RequestScope {
             bridge_->compileAndExecuteFile((*config_)->bootstrap_php_part_file);
             bridge_->callPHPSideEntryPoint(log_->getMaxLogLevel(), requestStartTime);
         } catch (std::exception const &e) {
-            ELOG_CRITICAL(log_, "Unable to bootstrap PHP-side instrumentation '%s'", e.what());
+            ELOGF_CRITICAL(log_, REQUEST, "Unable to bootstrap PHP-side instrumentation '%s'", e.what());
             return false;
         }
 
diff --git a/prod/native/libcommon/code/transport/CurlSender.cpp b/prod/native/libcommon/code/transport/CurlSender.cpp
index 684ab53..fe6094c 100644
--- a/prod/native/libcommon/code/transport/CurlSender.cpp
+++ b/prod/native/libcommon/code/transport/CurlSender.cpp
@@ -25,7 +25,7 @@ namespace elasticapm::php::transport {
 
 static int CurlDebugFunc(CURL *handle, curl_infotype type, char *data, size_t size, void *logger) {
     auto &log = *static_cast<std::shared_ptr<LoggerInterface> *>(logger);
-    if (logger && log->doesMeetsLevelCondition(LogLevel::logLevel_trace) && type < 3) {
+    if (logger && log->doesFeatureMeetsLevelCondition(LogLevel::logLevel_trace, elasticapm::php::LogFeature::TRANSPORT) && type < 3) {
         char prefix = type == CURLINFO_TEXT ? '*' : (type == CURLINFO_HEADER_IN ? '<' : '>');
         log->printf(LogLevel::logLevel_trace, "CurlSender %c %.*s", prefix, size - 1, data);
     }
diff --git a/prod/native/libcommon/code/transport/HttpEndpoints.h b/prod/native/libcommon/code/transport/HttpEndpoints.h
index 020aaec..bd46844 100644
--- a/prod/native/libcommon/code/transport/HttpEndpoints.h
+++ b/prod/native/libcommon/code/transport/HttpEndpoints.h
@@ -45,7 +45,7 @@ class HttpEndpoints {
         std::lock_guard<std::mutex> lock(mutex_);
         auto result = endpoints_.try_emplace(endpointHash, std::move(endpointUrl), std::move(contentType), endpointHeaders, maxRetries, retryDelay);
         if (connections_.try_emplace(result.first->second.getConnectionId(), log_, timeout, verifyServerCertificate).second) { // CurlSender
-            ELOG_DEBUG(log_, "HttpEndpoints::add endpointUrl '%s' enpointHash: %X initialize new connectionId: %X", result.first->second.getEndpoint().c_str(), endpointHash, result.first->second.getConnectionId());
+            ELOGF_DEBUG(log_, TRANSPORT, "HttpEndpoints::add endpointUrl '%s' enpointHash: %X initialize new connectionId: %X", result.first->second.getEndpoint().c_str(), endpointHash, result.first->second.getConnectionId());
             return true;
         }
         return false;
diff --git a/prod/native/libcommon/code/transport/HttpTransportAsync.h b/prod/native/libcommon/code/transport/HttpTransportAsync.h
index a8324ce..3810df7 100644
--- a/prod/native/libcommon/code/transport/HttpTransportAsync.h
+++ b/prod/native/libcommon/code/transport/HttpTransportAsync.h
@@ -60,23 +60,23 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
     }
 
     void initializeConnection(std::string endpointUrl, size_t endpointHash, std::string contentType, HttpEndpoint::enpointHeaders_t const &endpointHeaders, std::chrono::milliseconds timeout, std::size_t maxRetries, std::chrono::milliseconds retryDelay) {
-        ELOG_DEBUG(log_, "HttpTransportAsync::initializeConnection endpointUrl '%s' enpointHash: %X timeout: %zums retries: %zu retry delay: %zums", endpointUrl.c_str(), endpointHash, timeout.count(), maxRetries, retryDelay.count());
+        ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::initializeConnection endpointUrl '%s' enpointHash: %X timeout: %zums retries: %zu retry delay: %zums", endpointUrl.c_str(), endpointHash, timeout.count(), maxRetries, retryDelay.count());
 
         try {
             endpoints_.add(std::move(endpointUrl), endpointHash, config_->get().verify_server_cert, std::move(contentType), endpointHeaders, timeout, maxRetries, retryDelay);
             startThread();
         } catch (std::exception const &error) {
-            ELOG_ERROR(log_, "HttpTransportAsync::initializeConnection exception '%s'", error.what());
+            ELOGF_ERROR(log_, TRANSPORT, "HttpTransportAsync::initializeConnection exception '%s'", error.what());
         }
     }
 
     void enqueue(size_t endpointHash, std::span<std::byte> payload) {
         {
             std::lock_guard<std::mutex> lock(mutex_);
-            ELOG_TRACE(log_, "HttpTransportAsync::enqueue enpointHash: %X payload size: %zu, current queue size %zu usage %zu bytes", endpointHash, payload.size(), payloadsToSend_.size(), payloadsByteUsage_);
+            ELOGF_TRACE(log_, TRANSPORT, "HttpTransportAsync::enqueue enpointHash: %X payload size: %zu, current queue size %zu usage %zu bytes", endpointHash, payload.size(), payloadsToSend_.size(), payloadsByteUsage_);
 
             if (payloadsByteUsage_ + payload.size() > config_->get().max_send_queue_size) {
-                ELOG_DEBUG(log_, "HttpTransportAsync::enqueue payloadsByteUsageLimit %zu reached. Payload will be dropped. enpointHash: %X payload size: %zu, current queue size %zu usage %zu bytes", config_->get().max_send_queue_size, endpointHash, payload.size(), payloadsToSend_.size(), payloadsByteUsage_);
+                ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::enqueue payloadsByteUsageLimit %zu reached. Payload will be dropped. enpointHash: %X payload size: %zu, current queue size %zu usage %zu bytes", config_->get().max_send_queue_size, endpointHash, payload.size(), payloadsToSend_.size(), payloadsByteUsage_);
                 return;
             }
 
@@ -89,7 +89,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
     void prefork() final {
         shutdownThread();
 
-        ELOG_DEBUG(log_, "HttpTransportAsync::prefork payloads queue size %zu", payloadsToSend_.size());
+        ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::prefork payloads queue size %zu", payloadsToSend_.size());
         CurlCleanup();
     }
 
@@ -97,7 +97,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
         CurlInit();
 
         if (child && !payloadsToSend_.empty()) {
-            ELOG_DEBUG(log_, "HttpTransportAsync::postfork child emptying payloads queue. %zu will be sent from parent", payloadsToSend_.size());
+            ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::postfork child emptying payloads queue. %zu will be sent from parent", payloadsToSend_.size());
             decltype(payloadsToSend_) q;
             payloadsToSend_.swap(q);
         }
@@ -110,7 +110,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
     void startThread() {
         std::lock_guard<std::mutex> lock(mutex_);
         if (!thread_) {
-            ELOG_DEBUG(log_, "HttpTransportAsync startThread");
+            ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync startThread");
             thread_ = std::make_unique<std::thread>([this]() { asyncSender(); });
         }
     }
@@ -119,7 +119,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
         {
             std::lock_guard<std::mutex> lock(mutex_);
             if (thread_) {
-                ELOG_DEBUG(log_, "HttpTransportAsync shutdownThread");
+                ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync shutdownThread");
             }
 
             working_ = false;
@@ -133,7 +133,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
     }
 
     void asyncSender() {
-        ELOG_DEBUG(log_, "HttpTransportAsync::asyncSender blocking signals and starting work");
+        ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::asyncSender blocking signals and starting work");
 
         elasticapm::utils::blockApacheAndPHPSignals();
 
@@ -155,7 +155,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
             payloadsToSend_.pop();
             payloadsByteUsage_ -= payload.size();
 
-            ELOG_TRACE(log_, "HttpTransportAsync::send enpointHash: %X payload size: %zu", endpointHash, payload.size());
+            ELOGF_TRACE(log_, TRANSPORT, "HttpTransportAsync::send enpointHash: %X payload size: %zu", endpointHash, payload.size());
 
             lockedPayloadsMutex.unlock();
 
@@ -167,7 +167,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
                     while (retry < maxRetries) {
                         auto responseCode = conn.sendPayload(endpointUrl, headers, payload);
 
-                        ELOG_TRACE(log_, "HttpTransportAsync::send enpointHash: %X connectionId: %X payload size: %zu responseCode %d", endpointHash, connId, payload.size(), static_cast<int>(responseCode));
+                        ELOGF_TRACE(log_, TRANSPORT, "HttpTransportAsync::send enpointHash: %X connectionId: %X payload size: %zu responseCode %d", endpointHash, connId, payload.size(), static_cast<int>(responseCode));
 
                         if (responseCode >= 200 && responseCode < 300) {
                             break;
@@ -180,22 +180,22 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
                         }
 
                         retry++;
-                        ELOG_DEBUG(log_, "HttpTransportAsync::send enpointHash: %X connectionId: %X payload size: %zu retry %zu/%zu delay: %zu responseCode %d ", endpointHash, connId, payload.size(), retry, maxRetries, retryDelay.count(), static_cast<int>(responseCode));
+                        ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::send enpointHash: %X connectionId: %X payload size: %zu retry %zu/%zu delay: %zu responseCode %d ", endpointHash, connId, payload.size(), retry, maxRetries, retryDelay.count(), static_cast<int>(responseCode));
                         std::this_thread::sleep_for(retryDelay);
                     }
-                    ELOG_DEBUG(log_, "HttpTransportAsync::send enpointHash: %X connectionId: %X payload size: %zu", endpointHash, connId, payload.size());
+                    ELOGF_DEBUG(log_, TRANSPORT, "HttpTransportAsync::send enpointHash: %X connectionId: %X payload size: %zu", endpointHash, connId, payload.size());
                 } catch (std::runtime_error const &e) {
-                    ELOG_WARNING(log_, "HttpTransportAsync::send exception '%s'. enpointHash: %X connectionId: %X payload size: %zu", e.what(), endpointHash, connId, payload.size());
+                    ELOGF_WARNING(log_, TRANSPORT, "HttpTransportAsync::send exception '%s'. enpointHash: %X connectionId: %X payload size: %zu", e.what(), endpointHash, connId, payload.size());
                 }
             } catch (std::runtime_error const &error) {
-                ELOG_WARNING(log_, "HttpTransportAsync::send %s", error.what());
+                ELOGF_WARNING(log_, TRANSPORT, "HttpTransportAsync::send %s", error.what());
             }
 
             lockedPayloadsMutex.lock();
 
             // it will break sending and emit log if class destructor was triggered, payloads queue is not empty and timeout was set and reached
             if (forceFlushOnDestruction_ && !payloadsToSend_.empty() && config_->get().async_transport_shutdown_timeout.count() > 0 && ((std::chrono::steady_clock::now() - shutdownStart_) >= config_->get().async_transport_shutdown_timeout)) {
-                ELOG_WARNING(log_, "Dropping %zu payloads because ELASTIC_OTEL_ASYNC_TRANSPORT_SHUTDOWN_TIMEOUT (%zums) was reached", payloadsToSend_.size(), config_->get().async_transport_shutdown_timeout.count());
+                ELOGF_WARNING(log_, TRANSPORT, "Dropping %zu payloads because ELASTIC_OTEL_ASYNC_TRANSPORT_SHUTDOWN_TIMEOUT (%zums) was reached", payloadsToSend_.size(), config_->get().async_transport_shutdown_timeout.count());
                 break;
             }
         }
@@ -204,7 +204,7 @@ class HttpTransportAsync : public ForkableInterface, public boost::noncopyable {
     void CurlInit() {
         auto curlInitResult = curl_global_init(CURL_GLOBAL_ALL);
         if (curlInitResult != CURLE_OK) {
-            ELOG_ERROR(log_, "HttpTransportAsync curl_global_init failed: %s (%d)", curl_easy_strerror(curlInitResult), (int)curlInitResult);
+            ELOGF_ERROR(log_, TRANSPORT, "HttpTransportAsync curl_global_init failed: %s (%d)", curl_easy_strerror(curlInitResult), (int)curlInitResult);
         }
     }
     void CurlCleanup() {
diff --git a/prod/native/libcommon/test/CommonUtilsTest.cpp b/prod/native/libcommon/test/CommonUtilsTest.cpp
index 607d0cb..4e511e1 100644
--- a/prod/native/libcommon/test/CommonUtilsTest.cpp
+++ b/prod/native/libcommon/test/CommonUtilsTest.cpp
@@ -19,12 +19,15 @@
 
 
 #include "CommonUtils.h"
+#include "LogFeature.h"
+#include "Logger.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <pthread.h>
 
 #include <chrono>
+#include <memory>
 #include <string_view>
 
 
@@ -32,7 +35,22 @@ using namespace std::literals;
 
 namespace elasticapm::utils {
 
-TEST(CommunUtilsTest, convertDurationWithUnit) {
+class CommonUtilsTest : public ::testing::Test {
+public:
+    CommonUtilsTest() {
+
+        if (std::getenv("ELASTIC_OTEL_DEBUG_LOG_TESTS")) {
+            auto serr = std::make_shared<elasticapm::php::LoggerSinkStdErr>();
+            serr->setLevel(logLevel_trace);
+            reinterpret_cast<elasticapm::php::Logger *>(log_.get())->attachSink(serr);
+        }
+    }
+
+protected:
+    std::shared_ptr<elasticapm::php::LoggerInterface> log_ = std::make_shared<elasticapm::php::Logger>(std::vector<std::shared_ptr<elasticapm::php::LoggerSinkInterface>>());
+};
+
+TEST_F(CommonUtilsTest, convertDurationWithUnit) {
     EXPECT_THROW(convertDurationWithUnit("1  s  s"), std::invalid_argument);
     EXPECT_THROW(convertDurationWithUnit("1xd"), std::invalid_argument);
     EXPECT_THROW(convertDurationWithUnit("1h"), std::invalid_argument);
@@ -56,7 +74,7 @@ TEST(CommunUtilsTest, convertDurationWithUnit) {
     ASSERT_EQ(convertDurationWithUnit("  1234  \t"), 1234ms);
 }
 
-TEST(CommunUtilsTest, parseByteUnits) {
+TEST_F(CommonUtilsTest, parseByteUnits) {
     EXPECT_THROW(parseByteUnits("1  s  s"), std::invalid_argument);
     EXPECT_THROW(parseByteUnits("1xd"), std::invalid_argument);
     EXPECT_THROW(parseByteUnits("1h"), std::invalid_argument);
@@ -74,7 +92,7 @@ TEST(CommunUtilsTest, parseByteUnits) {
     ASSERT_EQ(parseByteUnits("0"), 0u);
 }
 
-TEST(CommunUtilsTest, parseBoolean) {
+TEST_F(CommonUtilsTest, parseBoolean) {
     ASSERT_TRUE(parseBoolean("true"));
     ASSERT_TRUE(parseBoolean("on"));
     ASSERT_TRUE(parseBoolean("yes"));
@@ -97,7 +115,7 @@ TEST(CommunUtilsTest, parseBoolean) {
     ASSERT_FALSE(parseBoolean(" "));
 }
 
-TEST(CommunUtilsTest, parseLogLevel) {
+TEST_F(CommonUtilsTest, parseLogLevel) {
     ASSERT_THROW(parseLogLevel("some unknown"), std::invalid_argument);
     ASSERT_EQ(parseLogLevel("   critical"), LogLevel::logLevel_critical);
     ASSERT_EQ(parseLogLevel("   CriticaL"), LogLevel::logLevel_critical);
@@ -110,8 +128,7 @@ TEST(CommunUtilsTest, parseLogLevel) {
     ASSERT_THROW(parseLogLevel("TRACER"), std::invalid_argument);
 }
 
-
-TEST(CommunUtilsTest, getParameterizedString) {
+TEST_F(CommonUtilsTest, getParameterizedString) {
     ASSERT_EQ(getParameterizedString("example_name"), "example_name");
     ASSERT_EQ(getParameterizedString("example_name_%p"), std::string("example_name_") + std::to_string(getpid()));
     ASSERT_EQ(getParameterizedString("%p_example_name"), std::to_string(getpid()) + std::string("_example_name"));
@@ -126,7 +143,7 @@ TEST(CommunUtilsTest, getParameterizedString) {
     ASSERT_EQ(getParameterizedString("example_%X_name"), "example_%X_name");
 }
 
-TEST(CommunUtilsTest, trim) {
+TEST_F(CommonUtilsTest, trim) {
     using namespace std::string_view_literals;
     ASSERT_EQ(trim("example_name"sv), "example_name"sv);
     ASSERT_EQ(trim("\nexample_name"sv), "example_name"sv);
@@ -137,7 +154,7 @@ TEST(CommunUtilsTest, trim) {
     ASSERT_EQ(trim("   "sv), ""sv);
 }
 
-TEST(CommunUtilsTest, sanitizeKeyValueString) {
+TEST_F(CommonUtilsTest, sanitizeKeyValueString) {
     using namespace std::literals;
 
     ASSERT_EQ(sanitizeKeyValueString("ELASTIC_OTEL_API_KEY"s, "ELASTIC_OTEL_API_KEY=supersecret"s), "ELASTIC_OTEL_API_KEY=***"s);
@@ -146,21 +163,21 @@ TEST(CommunUtilsTest, sanitizeKeyValueString) {
     ASSERT_EQ(sanitizeKeyValueString("ELASTIC_OTEL_API_KEY"s, "THIS IS A TEXT ELASTIC_OTEL_API_KEY=\"aaa with spaces\" EXAMPLE"s), "THIS IS A TEXT ELASTIC_OTEL_API_KEY=*** EXAMPLE"s);
 }
 
-TEST(CommunUtilsTest, stringPrintf) {
+TEST_F(CommonUtilsTest, stringPrintf) {
     ASSERT_EQ(stringPrintf("%s is %d years old", "Mark", 12), "Mark is 12 years old"s);
 }
 
-TEST(CommunUtilsTest, getIniName) {
+TEST_F(CommonUtilsTest, getIniName) {
     ASSERT_EQ(getIniName("basic_option"), "elastic_otel.basic_option"s);
     ASSERT_EQ(getIniName("OtherOption"), "elastic_otel.OtherOption"s);
 }
 
-TEST(CommunUtilsTest, getEnvName) {
+TEST_F(CommonUtilsTest, getEnvName) {
     ASSERT_EQ(getEnvName("basic_option"), "ELASTIC_OTEL_BASIC_OPTION"s);
     ASSERT_EQ(getEnvName("OtherOption"), "ELASTIC_OTEL_OTHEROPTION"s);
 }
 
-TEST(CommonUtilsTest, getConnectionDetailsFromURL) {
+TEST_F(CommonUtilsTest, getConnectionDetailsFromURL) {
     ASSERT_EQ(getConnectionDetailsFromURL("https://localhost/?query=asdsad").value_or(""), "https://localhost"s);
     ASSERT_EQ(getConnectionDetailsFromURL("http://localhost/?query=asdsad").value_or(""), "http://localhost"s);
     ASSERT_EQ(getConnectionDetailsFromURL("http://localhost:8080/?query=asdsad").value_or(""), "http://localhost:8080"s);
@@ -171,5 +188,43 @@ TEST(CommonUtilsTest, getConnectionDetailsFromURL) {
     ASSERT_EQ(getConnectionDetailsFromURL("localhost"), std::nullopt);
     ASSERT_EQ(getConnectionDetailsFromURL("ftp:://localhost"), std::nullopt);
 }
+
+TEST_F(CommonUtilsTest, parseLogFeatures_Empty) {
+    auto features = parseLogFeatures(log_, "");
+    ASSERT_TRUE(features.empty());
+}
+
+TEST_F(CommonUtilsTest, parseLogFeatures_UnknownFeature) {
+    auto features = parseLogFeatures(log_, "UNKNOWNFEATURE=debug");
+    ASSERT_TRUE(features.empty());
+}
+
+TEST_F(CommonUtilsTest, parseLogFeatures_UnknownLevel) {
+    auto features = parseLogFeatures(log_, "ALL=unknown");
+    ASSERT_TRUE(features.empty());
+}
+
+TEST_F(CommonUtilsTest, parseLogFeatures_UnknownAndCorrectFeature) {
+    auto features = parseLogFeatures(log_, "UNKNOWNFEATURE=debug,ALL=info");
+    ASSERT_EQ(features.size(), 1u);
+    auto found = features.find(elasticapm::php::LogFeature::ALL);
+    ASSERT_NE(found, std::end(features));
+    ASSERT_EQ(found->second, LogLevel::logLevel_info);
+}
+
+TEST_F(CommonUtilsTest, parseLogFeatures_MultipleFeatures) {
+    auto features = parseLogFeatures(log_, "ALL=info,TRANSPORT=debug");
+    ASSERT_EQ(features.size(), 2u);
+    {
+        auto found = features.find(elasticapm::php::LogFeature::ALL);
+        ASSERT_NE(found, std::end(features));
+        ASSERT_EQ(found->second, LogLevel::logLevel_info);
+    }
+    {
+        auto found = features.find(elasticapm::php::LogFeature::TRANSPORT);
+        ASSERT_NE(found, std::end(features));
+        ASSERT_EQ(found->second, LogLevel::logLevel_debug);
+    }
+}
 }
 
diff --git a/prod/native/libphpbridge/code/OpCache.cpp b/prod/native/libphpbridge/code/OpCache.cpp
index 55821b8..f4841f3 100644
--- a/prod/native/libphpbridge/code/OpCache.cpp
+++ b/prod/native/libphpbridge/code/OpCache.cpp
@@ -65,7 +65,7 @@ bool PhpBridge::isScriptRestricedByOpcacheAPI() const {
     if (!SG(request_info).path_translated ||
         strlen(SG(request_info).path_translated) < len ||
         memcmp(SG(request_info).path_translated, restrict_api, len) != 0) {
-        ELOG_WARNING(log_, "Script '%s' is restricted by \"opcache.restrict_api\" configuration directive. Can't perform any opcache API calls.", SG(request_info).path_translated);
+        ELOGF_WARNING(log_, REQUEST, "Script '%s' is restricted by \"opcache.restrict_api\" configuration directive. Can't perform any opcache API calls.", SG(request_info).path_translated);
         return true;
     }
     return false;
@@ -90,12 +90,12 @@ bool PhpBridge::detectOpcacheRestartPending() const {
 	EG(error_reporting) = originalErrorReportingState;
 
     if (!result) {
-        ELOG_ERROR(log_, "opcache_get_status failure");
+        ELOGF_ERROR(log_, REQUEST, "opcache_get_status failure");
         return false;
     }
 
     if (Z_TYPE(*rv) != IS_ARRAY) {
-        ELOG_DEBUG(log_, "opcache_get_status failed, rvtype: %d", Z_TYPE(*rv));
+        ELOGF_DEBUG(log_, REQUEST, "opcache_get_status failed, rvtype: %d", Z_TYPE(*rv));
         return false;
     }
 
@@ -103,7 +103,7 @@ bool PhpBridge::detectOpcacheRestartPending() const {
     if (restartPending && Z_TYPE_P(restartPending) == IS_TRUE) {
         return true;
     } else if (!restartPending || Z_TYPE_P(restartPending) != IS_FALSE) {
-        ELOG_DEBUG(log_, "opcache_get_status returned unexpected data ptr: %p t:%d", restartPending, restartPending ? Z_TYPE_P(restartPending) : -1);
+        ELOGF_DEBUG(log_, REQUEST, "opcache_get_status returned unexpected data ptr: %p t:%d", restartPending, restartPending ? Z_TYPE_P(restartPending) : -1);
     }
     return false;
 }
diff --git a/prod/php/ElasticOTel/BootstrapStageLogger.php b/prod/php/ElasticOTel/BootstrapStageLogger.php
index b73e7c8..fb909ca 100644
--- a/prod/php/ElasticOTel/BootstrapStageLogger.php
+++ b/prod/php/ElasticOTel/BootstrapStageLogger.php
@@ -25,6 +25,8 @@
 
 use Throwable;
 
+require __DIR__ . DIRECTORY_SEPARATOR . 'Log' . DIRECTORY_SEPARATOR . 'LogFeature.php';
+
 /**
  * Code in this file is part of implementation internals, and thus it is not covered by the backward compatibility.
  *
@@ -233,9 +235,10 @@ private static function logWithLevel(int $statementLevel, string $message, strin
          * @noinspection PhpFullyQualifiedNameUsageInspection, PhpUndefinedFunctionInspection
          * @phpstan-ignore-next-line
          */
-        \elastic_otel_log(
+        \elastic_otel_log_feature(
             0 /* $isForced */,
             $statementLevel,
+            LogFeature::BOOTSTRAP,
             self::LOG_CATEGORY,
             self::processSourceCodeFilePathForLog($file),
             $line,
diff --git a/prod/php/ElasticOTel/Log/LogFeature.php.template b/prod/php/ElasticOTel/Log/LogFeature.php.template
new file mode 100644
index 0000000..366b5a5
--- /dev/null
+++ b/prod/php/ElasticOTel/Log/LogFeature.php.template
@@ -0,0 +1,30 @@
+<?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.
+ */
+
+/* this file is generated, do not edit it manually */
+
+declare(strict_types=1);
+
+namespace Elastic\OTel;
+
+final class LogFeature {
+@_PROJECT_PROPERTIES_LOGGER_FEATURES_ENUM_VALUES@
+}
diff --git a/prod/php/ElasticOTel/PhpPartVersion.php.template b/prod/php/ElasticOTel/PhpPartVersion.php.template
index fa59f24..feb4d81 100644
--- a/prod/php/ElasticOTel/PhpPartVersion.php.template
+++ b/prod/php/ElasticOTel/PhpPartVersion.php.template
@@ -25,4 +25,4 @@ declare(strict_types=1);
 
 namespace Elastic\OTel;
 
-const ELASTIC_OTEL_PHP_VERSION = '__ELASTIC_OTEL_PHP_VERSION__';
+const ELASTIC_OTEL_PHP_VERSION = '@_PROJECT_PROPERTIES_VERSION@';
diff --git a/tools/build/configure_php_templates.sh b/tools/build/configure_php_templates.sh
new file mode 100755
index 0000000..313703c
--- /dev/null
+++ b/tools/build/configure_php_templates.sh
@@ -0,0 +1,110 @@
+#!/bin/bash
+#
+# This script generates PHP files from template files.
+# The data to populate the templates is retrieved from the elastic-otel-php.properties file
+# using the read_properties.sh script, which processes the properties and stores them
+# in environment variables with the _PROJECT_PROPERTIES prefix.
+# In the template file, each text of the form @_PROJECT_PROPERTIES_SOME_VARIABLE@
+# will be replaced with the content of the environment variable _PROJECT_PROPERTIES_SOME_VARIABLE
+
+set -o pipefail
+set -e
+set -u
+
+source ./tools/read_properties.sh
+
+read_properties elastic-otel-php.properties _PROJECT_PROPERTIES
+
+# The function only works if the environment variable GITHUB_SHA is not set
+# It retrieves the hash of the current commit, and appends '-dirty' if there are local changes
+# Arguments:
+#   none
+# Returns:
+#   The git hash string will be printed to stdout
+get_git_hash() {
+    if [ -z "${GITHUB_SHA+x}" ]; then
+        IS_DIRTY=false
+
+        git diff-index --quiet HEAD --
+        GIT_RESULT=$?
+
+        if [ $GIT_RESULT -ne 0 ]; then
+            IS_DIRTY=true
+        fi
+
+        GIT_VERSION=$(git rev-parse --short HEAD 2>/dev/null)
+        GIT_RESULT=$?
+
+        if [ $GIT_RESULT -ne 0 ]; then
+            TMP_OUTPUT_HASH=""
+        else
+            if [ "$IS_DIRTY" = true ]; then
+                TMP_OUTPUT_HASH="~${GIT_VERSION}-dirty"
+            else
+                TMP_OUTPUT_HASH="~${GIT_VERSION}"
+            fi
+        fi
+
+        echo "$TMP_OUTPUT_HASH"
+    fi
+}
+
+# Transform comma-separated values into a PHP 8.0 compatible "enum" class
+# Arguments:
+#   1 - input values like "VAL=0,VAL2=0,VAL3=0"
+# Returns:
+#   PHP-style const class members will be printed to stdout
+transform_comma_separated_values_into_php_const_members() {
+    local _ARG_INPUT_VALUES=$1
+
+    IFS="," read -ra _ARG_INPUT_VALUES_ARRAY <<< ${_ARG_INPUT_VALUES}
+    for _VAL in "${_ARG_INPUT_VALUES_ARRAY[@]}"; do
+        echo "    public const ${_VAL};"
+    done
+}
+
+# Replaces placeholders of the form @VAR@ with the values of the corresponding environment variables VAR
+# Arguments:
+#   1 - input file name (template)
+# Returns:
+#   The content of the file after replacement will be printed to stdout
+function configure_file() {
+    local _ARG_INPUT_FILE=$1
+
+    while IFS= read -r line; do
+        while [[ "$line" =~ @(.*?)@ ]]; do
+            var_name="${BASH_REMATCH[1]}"  # find var name
+            var_value="${!var_name}"       # get var value
+            line="${line//@${var_name}@/${var_value}}"  # replace @VAR@ with value
+        done
+        echo "$line"
+    done < ${_ARG_INPUT_FILE}
+}
+
+# Replaces placeholders of the form @VAR@ with the values of the corresponding environment variables VAR
+# Arguments:
+#   1 - input filename ending with *.template
+# Returns:
+#   The resulting file with the .template extension removed
+function configure_from_template() {
+    local _ARG_INPUT_FILE=$1
+
+    if [[ "${_ARG_INPUT_FILE}" != *.template ]]; then
+        echo "configure_from_template error: File name must end with '.template'" >&2
+        exit 1
+    fi
+
+    local _OUTPUT_FILE=${_ARG_INPUT_FILE%.template}
+
+    echo "Configuring file ${_OUTPUT_FILE} from ${_ARG_INPUT_FILE}"
+
+    configure_file "${_ARG_INPUT_FILE}" >"${_OUTPUT_FILE}"
+}
+
+# Transform values read from properties before templating
+
+_PROJECT_PROPERTIES_LOGGER_FEATURES_ENUM_VALUES=$(transform_comma_separated_values_into_php_const_members "${_PROJECT_PROPERTIES_LOGGER_FEATURES_ENUM_VALUES}")
+_PROJECT_PROPERTIES_VERSION="${_PROJECT_PROPERTIES_VERSION}$(get_git_hash)"
+
+configure_from_template "prod/php/ElasticOTel/Log/LogFeature.php.template"
+configure_from_template "prod/php/ElasticOTel/PhpPartVersion.php.template"
diff --git a/tools/build/generate_php_part_version.sh b/tools/build/generate_php_part_version.sh
deleted file mode 100755
index 70d80cd..0000000
--- a/tools/build/generate_php_part_version.sh
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/bin/bash
-
-source ./tools/read_properties.sh
-
-read_properties elastic-otel-php.properties ELASTIC_OTEL_PHP
-
-get_git_hash() {
-    if [ -z "${GITHUB_SHA}" ]; then
-        IS_DIRTY=false
-
-        git diff-index --quiet HEAD --
-        GIT_RESULT=$?
-
-        if [ $GIT_RESULT -ne 0 ]; then
-            IS_DIRTY=true
-        fi
-
-        GIT_VERSION=$(git rev-parse --short HEAD 2>/dev/null)
-        GIT_RESULT=$?
-
-        if [ $GIT_RESULT -ne 0 ]; then
-            TMP_OUTPUT_HASH=""
-        else
-            if [ "$IS_DIRTY" = true ]; then
-                TMP_OUTPUT_HASH="~${GIT_VERSION}-dirty"
-            else
-                TMP_OUTPUT_HASH="~${GIT_VERSION}"
-            fi
-        fi
-
-        echo "$TMP_OUTPUT_HASH"
-    fi
-}
-
-ELASTIC_OTEL_PHP_VERSION="${ELASTIC_OTEL_PHP_VERSION}$(get_git_hash)"
-
-sed "s/__ELASTIC_OTEL_PHP_VERSION__/$ELASTIC_OTEL_PHP_VERSION/g" prod/php/ElasticOTel/PhpPartVersion.php.template > prod/php/ElasticOTel/PhpPartVersion.php
-
-echo "The file prod/php/ElasticOTel/PhpPartVersion.php has been generated with version ${ELASTIC_OTEL_PHP_VERSION}"
\ No newline at end of file

From 7f3c8ab3dc88d04343fd9e066300f635dcf6e19a Mon Sep 17 00:00:00 2001
From: Pawel Filipczak <pawel.filipczak@elastic.co>
Date: Mon, 28 Oct 2024 10:55:23 +0100
Subject: [PATCH 2/2] Add missing generated file to dependencies

---
 .github/workflows/build-php-deps.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/build-php-deps.yml b/.github/workflows/build-php-deps.yml
index 33f6dbd..7ffadf7 100644
--- a/.github/workflows/build-php-deps.yml
+++ b/.github/workflows/build-php-deps.yml
@@ -25,4 +25,5 @@ jobs:
           path: |
             prod/php/vendor_*
             prod/php/ElasticOTel/PhpPartVersion.php
+            prod/php/ElasticOTel/Log/LogFeature.php
             NOTICE