Telemetry integration

Summary: Integrating telemetry T2 markers into Rialto
Type: Fix
Test Plan: UT/CT, Fullstack
Jira: RDKEMW-16516

Author: Koky2701

cmake/Findtelemetry.cmake

@@ -0,0 +1,69 @@
+#
+# If not stated otherwise in this file or this component's LICENSE file the
+# following copyright and licenses apply:
+#
+# Copyright 2026 Sky UK
+#
+# Licensed 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.
+#
+
+if(NOT NATIVE_BUILD)
+  find_path(TELEMETRY_INCLUDE_DIR NAMES telemetry_busmessage_sender.h)
+  find_library(TELEMETRY_LIBRARY NAMES telemetry_msgsender)
+
+  message(STATUS "Telemetry include dir: ${TELEMETRY_INCLUDE_DIR}")
+  message(STATUS "Telemetry library: ${TELEMETRY_LIBRARY}")
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(TELEMETRY DEFAULT_MSG TELEMETRY_LIBRARY TELEMETRY_INCLUDE_DIR)
+
+  mark_as_advanced(TELEMETRY_INCLUDE_DIR TELEMETRY_LIBRARY)
+
+  if(TELEMETRY_FOUND AND NOT TARGET telemetry)
+    add_library(telemetry SHARED IMPORTED)
+    set_target_properties(telemetry PROPERTIES
+      IMPORTED_LOCATION "${TELEMETRY_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${TELEMETRY_INCLUDE_DIR}")
+  endif()
+else()
+  include(ExternalProject)
+  set_property(DIRECTORY PROPERTY EP_BASE "${CMAKE_CURRENT_BINARY_DIR}/third-party")
+
+  ExternalProject_Add(
+    telemetry-source
+    GIT_REPOSITORY https://github.com/rdkcentral/telemetry.git
+    GIT_TAG develop
+    PREFIX ${CMAKE_CURRENT_BINARY_DIR}/third-party
+    BUILD_IN_SOURCE 1
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND make
+    INSTALL_COMMAND ""
+  )
+
+  ExternalProject_Get_Property(telemetry-source SOURCE_DIR)
+
+  set(TELEMETRY_INCLUDE_DIR ${SOURCE_DIR}/include)
+  set(TELEMETRY_LIBRARY ${SOURCE_DIR}/lib/libtelemetry_msgsender.so)
+
+  message(STATUS "Telemetry include dir (native): ${TELEMETRY_INCLUDE_DIR}")
+  message(STATUS "Telemetry library (native): ${TELEMETRY_LIBRARY}")
+
+  add_library(telemetry SHARED IMPORTED)
+  set_target_properties(telemetry PROPERTIES
+    IMPORTED_LOCATION "${TELEMETRY_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${TELEMETRY_INCLUDE_DIR}"
+    IMPORTED_NO_SONAME TRUE
+  )
+
+  add_dependencies(telemetry telemetry-source)
+endif()

logging/CMakeLists.txt

@@ -33,8 +33,11 @@ set(RialtoLogging_INCLUDES
     "${CMAKE_CURRENT_SOURCE_DIR}/include"
     )
 
+find_package(telemetry REQUIRED)
+
 add_library(RialtoLogging STATIC ${RialtoLogging_HEADERS} ${RialtoLogging_SOURCES})
 target_include_directories(RialtoLogging PUBLIC "$<BUILD_INTERFACE:${RialtoLogging_INCLUDES}>")
+target_link_libraries(RialtoLogging PUBLIC telemetry)
 set_target_properties(RialtoLogging PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
 set_target_properties(RialtoLogging PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
@@ -44,7 +47,7 @@ if (EthanLog_FOUND AND RIALTO_ENABLE_ETHAN_LOG)
     add_library(RialtoEthanLog STATIC ${RialtoLogging_HEADERS} ${RialtoLogging_SOURCES})
     target_include_directories(RialtoEthanLog PUBLIC "$<BUILD_INTERFACE:${RialtoLogging_INCLUDES}>")
     target_compile_definitions(RialtoEthanLog PRIVATE USE_ETHANLOG)
-    target_link_libraries(RialtoEthanLog PUBLIC EthanLog::EthanLog)
+    target_link_libraries(RialtoEthanLog PUBLIC EthanLog::EthanLog telemetry)
     set_target_properties(RialtoEthanLog PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
     set_target_properties(RialtoEthanLog PROPERTIES POSITION_INDEPENDENT_CODE ON)
 else ()

logging/include/RialtoLogging.h

@@ -27,6 +27,7 @@ extern "C"
 
 #include <stdarg.h>
 #include <stdint.h>
+#include "RialtoTelemetry.h"
 
     /**
      * Defined log levels used to set the required output logs for the component

logging/include/RialtoTelemetry.h

@@ -0,0 +1,58 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2026 Sky UK
+ *
+ * Licensed 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.
+ */
+
+#ifndef __RIALTO_TELEMETRY_H__
+#define __RIALTO_TELEMETRY_H__
+
+#include <telemetry_busmessage_sender.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TELEMETRY_INIT(component) \
+    do { \
+        t2_init((char*)component); \
+    } while(0)
+
+#define TELEMETRY_UNINIT() \
+    do { \
+        t2_uninit(); \
+    } while(0)
+
+#define TELEMETRY_EVENT_STRING(marker, value) \
+    do { \
+        t2_event_s((char*)marker, (char*)value); \
+    } while(0)
+
+#define TELEMETRY_EVENT_FLOAT(marker, value) \
+    do { \
+        t2_event_f((char*)marker, (double)value); \
+    } while(0)
+
+#define TELEMETRY_EVENT_INT(marker, value) \
+    do { \
+        t2_event_d((char*)marker, (int)value); \
+    } while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __RIALTO_TELEMETRY_H__ */

media/client/common/include/RialtoClientLogging.h

@@ -21,6 +21,7 @@
 #define RIALTO_CLIENT_LOGGING_H_
 
 #include "RialtoLogging.h"
+#include <cstdio>
 
 #ifdef __cplusplus
 extern "C"

media/client/ipc/CMakeLists.txt

@@ -67,4 +67,5 @@ target_link_libraries (
         RialtoPlayerCommon
         RialtoEthanLog
         RialtoProtobuf
+        telemetry
 )

media/client/ipc/source/ControlIpc.cpp

@@ -115,6 +115,10 @@ bool ControlIpc::getSharedMemory(int32_t &fd, uint32_t &size)
     if (ipcController->Failed())
     {
         RIALTO_CLIENT_LOG_ERROR("failed to get the shared memory due to '%s'", ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to get the shared memory due to '%s'",
+                 ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - ControllIpc", telemetryBuff);
         return false;
     }
 
@@ -152,6 +156,10 @@ bool ControlIpc::registerClient()
     if (ipcController->Failed())
     {
         RIALTO_CLIENT_LOG_ERROR("failed to register client due to '%s'", ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to register client due to '%s'",
+                 ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - ControllIpc", telemetryBuff);
         return false;
     }
 
@@ -181,6 +189,13 @@ bool ControlIpc::registerClient()
         RIALTO_CLIENT_LOG_ERROR("Server and Client proto schema versions are not compatible. Server schema version: "
                                 "%s, Client schema version: %s",
                                 kServerSchemaVersion.str().c_str(), kCurrentSchemaVersion.str().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff),
+                 "Server and Client proto schema versions are not compatible. Server schema version: "
+                 "%s, Client schema version: %s",
+                 kServerSchemaVersion.str().c_str(), kCurrentSchemaVersion.str().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - ControllIpc", telemetryBuff);
+
         return false;
     }
 
@@ -260,6 +275,9 @@ void ControlIpc::onPing(const std::shared_ptr<firebolt::rialto::PingEvent> &even
     if (ipcController->Failed())
     {
         RIALTO_CLIENT_LOG_ERROR("failed to ack due to '%s'", ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to ack due to '%s'", ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - ControllIpc", telemetryBuff);
     }
 }
 }; // namespace firebolt::rialto::client

media/client/ipc/source/IpcClient.cpp

@@ -19,7 +19,6 @@
 
 #include "IpcClient.h"
 #include "RialtoClientLogging.h"
-#include <utility>
 
 namespace firebolt::rialto::client
 {
@@ -159,6 +158,10 @@ void IpcClient::processIpcThread()
     if (!m_disconnecting)
     {
         RIALTO_CLIENT_LOG_ERROR("The ipc channel unexpectedly disconnected, destroying the channel");
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff),
+                 "The ipc channel unexpectedly disconnected, destroying the channel");
+        TELEMETRY_EVENT_STRING("Rialto Client - IpcClient", telemetryBuff);
 
         // Safe to destroy the ipc objects in the ipc thread as the client has already disconnected.
         // This ensures the channel is destructed and that all ongoing ipc calls are unblocked.
@@ -192,7 +195,7 @@ std::shared_ptr<ipc::IBlockingClosure> IpcClient::createBlockingClosure()
     // check which thread we're being called from, this determines if we pump
     // event loop from within the wait() method or not
     if (m_ipcThread.get_id() == std::this_thread::get_id())
-        return m_blockingClosureFactory->createBlockingClosurePoll(std::move(ipcChannel));
+        return m_blockingClosureFactory->createBlockingClosurePoll(ipcChannel);
     else
         return m_blockingClosureFactory->createBlockingClosureSemaphore();
 }

media/client/ipc/source/MediaKeysCapabilitiesIpc.cpp

@@ -36,6 +36,10 @@ std::shared_ptr<IMediaKeysCapabilitiesIpcFactory> IMediaKeysCapabilitiesIpcFacto
     catch (const std::exception &e)
     {
         RIALTO_CLIENT_LOG_ERROR("Failed to create the media keys capabilities ipc factory, reason: %s", e.what());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff),
+                 "Failed to create the media keys capabilities ipc factory, reason: %s", e.what());
+        TELEMETRY_EVENT_STRING("Rialto Client - MediaKeysCapabilitiesIpc", telemetryBuff);
     }
 
     return factory;
@@ -58,6 +62,10 @@ std::shared_ptr<IMediaKeysCapabilities> MediaKeysCapabilitiesIpcFactory::getMedi
         catch (const std::exception &e)
         {
             RIALTO_CLIENT_LOG_ERROR("Failed to create the media keys capabilities ipc, reason: %s", e.what());
+            char telemetryBuff[128] = {0};
+            snprintf(telemetryBuff, sizeof(telemetryBuff),
+                     "Failed to create the media keys capabilities ipc, reason: %s", e.what());
+            TELEMETRY_EVENT_STRING("Rialto Client - MediaKeysCapabilitiesIpc", telemetryBuff);
         }
 
         MediaKeysCapabilitiesIpcFactory::m_mediaKeysCapabilitiesIpc = mediaKeysCapabilitiesIpc;
@@ -115,6 +123,10 @@ std::vector<std::string> MediaKeysCapabilitiesIpc::getSupportedKeySystems()
     if (ipcController->Failed())
     {
         RIALTO_CLIENT_LOG_ERROR("failed to get supported key systems due to '%s'", ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to get supported key systems due to '%s'",
+                 ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - MediaKeysCapabilitiesIpc", telemetryBuff);
         return {};
     }
 
@@ -144,6 +156,10 @@ bool MediaKeysCapabilitiesIpc::supportsKeySystem(const std::string &keySystem)
     if (ipcController->Failed())
     {
         RIALTO_CLIENT_LOG_ERROR("failed to supports key system due to '%s'", ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to support key systems due to '%s'",
+                 ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - MediaKeysCapabilitiesIpc", telemetryBuff);
         return false;
     }
 
@@ -175,6 +191,10 @@ bool MediaKeysCapabilitiesIpc::getSupportedKeySystemVersion(const std::string &k
     {
         RIALTO_CLIENT_LOG_ERROR("failed to get supported key system version due to '%s'",
                                 ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to get supported key system versions due to '%s'",
+                 ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - MediaKeysCapabilitiesIpc", telemetryBuff);
         return false;
     }
     version = response.version();
@@ -207,6 +227,10 @@ bool MediaKeysCapabilitiesIpc::isServerCertificateSupported(const std::string &k
     {
         RIALTO_CLIENT_LOG_ERROR("failed to check if server certificate is supported due to '%s'",
                                 ipcController->ErrorText().c_str());
+        char telemetryBuff[128] = {0};
+        snprintf(telemetryBuff, sizeof(telemetryBuff), "Failed to check if server certificate is supported due to '%s'",
+                 ipcController->ErrorText().c_str());
+        TELEMETRY_EVENT_STRING("Rialto Client - MediaKeysCapabilitiesIpc", telemetryBuff);
         return false;
     }