{"id":9708,"date":"2022-06-21T13:53:04","date_gmt":"2022-06-21T13:53:04","guid":{"rendered":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/"},"modified":"2026-08-07T10:55:27","modified_gmt":"2026-08-07T10:55:27","slug":"logger","status":"publish","type":"page","link":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/","title":{"rendered":"RDK Logger"},"content":{"rendered":"\n

RDK Logger is a general-purpose logging framework for RDK middleware components across video and broadband platform stacks. It provides a unified logging interface that standardizes how RDK components generate, filter, format, and route log messages. The framework supports configurable log levels per module through a centralized configuration file, enables runtime log level changes without service restarts, and routes output to multiple destinations including console, syslog, systemd journal, and rolling files.<\/p>\n\n\n\n

On video platforms, RDK Logger serves as the logging backbone for middleware components such as the application manager, media pipeline, compositor, and Thunder plugin ecosystem. On broadband platforms, it fulfills the same role for protocol agents, platform management, and connectivity services. The same library binary and configuration model apply across all platform stacks, with the module naming convention (LOG.RDK.<MODULE><\/code>) providing the separation boundary between subsystems.<\/p>\n\n\n\n

RDK Logger operates as a shared library (librdkloggers<\/code>) that client processes link against. It uses Log4C as its underlying backend for log routing and formatting, and exposes a compact C API centered on the RDK_LOG<\/code> macro. A companion command-line utility (rdklogctrl<\/code>) communicates with running processes over a local UDP socket to change log levels at runtime without requiring a restart.<\/p>\n\n\n\n

flowchart LR\n\n%% Styles\nclassDef RDKMW stroke:#75D701,fill:#F1FFE6,stroke-width:2px\nclassDef Logger stroke:#FF6B35,fill:#FFF0EA,stroke-width:3px\nclassDef VL stroke:#808080,fill:#F2F2F2,stroke-width:2px\n\nRDKMW[\"RDK Middleware Components\"]\nRDKLogger[\"RDK Logger\"]\nSysLog[\"Log4C \/ syslog\\n\/ systemd journal\\n\/ rolling files\"]\n\nRDKMW -->|RDK_LOG APIs| RDKLogger\nRDKLogger -->|Log4C APIs| SysLog\n\nclass RDKMW RDKMW\nclass RDKLogger Logger\nclass SysLog VL<\/pre><\/div>\n\n\n\n
Key Features & Responsibilities:<\/strong><\/p>\n\n\n\n
    \n
  • Unified Logging API<\/strong>: Provides the RDK_LOG(level, module, format, ...)<\/code> macro as a single, consistent logging interface used by all RDK middleware components, replacing direct use of printf<\/code>, fprintf<\/code>, or syslog<\/code>.<\/li>\n\n\n\n
  • Module-Specific Log Level Control<\/strong>: Maintains independent log level configuration per component using the LOG.RDK.<MODULE><\/code> naming convention. Modules not explicitly configured inherit the default level set under LOG.RDK.DEFAULT<\/code>.<\/li>\n\n\n\n
  • Three-Tier Configuration Override<\/strong>: Resolves the active configuration file at startup using a priority chain \u2014 \/opt\/debug.ini<\/code> (highest) \u2192 \/nvram\/debug.ini<\/code> \u2192 \/etc\/debug.ini<\/code> (default) \u2014 enabling field-level overrides without modifying the base system image.<\/li>\n\n\n\n
  • Runtime Log Level Control<\/strong>: The rdklogctrl<\/code> utility sends UDP control messages to running processes on port 12035, enabling immediate log level changes per module without process restart.<\/li>\n\n\n\n
  • Multiple Output Destinations<\/strong>: Supports console (stdout<\/code>\/stderr<\/code>), syslog daemon, systemd journal (when available), and rolling file appenders through a pluggable Log4C backend.<\/li>\n\n\n\n
  • Configurable Log Formats<\/strong>: Six log message layouts are available, ranging from plain text to detailed formats including timestamps, thread IDs, module name, and log level.<\/li>\n\n\n\n
  • Milestone Logging<\/strong>: Provides a dedicated logMilestone()<\/code> API that records timestamped system lifecycle events (using CLOCK_MONOTONIC_RAW<\/code>) to a dedicated milestones log file, separate from general component logs.<\/li>\n\n\n\n
  • Onboarding Log Support<\/strong>: Writes structured onboarding events to a dedicated log path during the device provisioning phase, with suppression logic based on provisioning state flags.<\/li>\n\n\n\n
  • Thread-Safe Operation<\/strong>: Uses mutex protection (pthread_mutex_t<\/code>) around initialization and log message dispatch, enabling safe concurrent use from multi-threaded RDK components without external synchronization.<\/li>\n\n\n\n
  • Performance-Optimized Filtering<\/strong>: Log level checks are performed before any formatting or output I\/O; when a level is disabled, the call avoids message formatting and backend writes (but still performs the mutex-protected category\/priority check and dynamic-control polling).<\/li>\n<\/ul>\n\n\n\n
    \n\n\n\n
    Design<\/h2>\n\n\n\n
    RDK Logger follows a modular library architecture where the logging policy, output routing, and runtime control concerns are separated into distinct subsystems. The public API layer provides the RDK_LOG<\/code> macro and initialization functions. A private implementation layer (rdk_debug_priv.c<\/code>) handles Log4C backend integration, configuration parsing, and the actual message dispatch. A runtime control layer (rdk_dynamic_logger.c<\/code>) implements a non-blocking UDP listener that processes log level change requests from the rdklogctrl<\/code> utility. This separation allows the logging path to remain lightweight while control plane operations are handled independently.<\/p>\n\n\n\n
    The design prioritizes minimal overhead on the fast logging path. Level checks are performed first, and if the level is disabled for the given module, the call returns immediately without any formatting or I\/O. Message formatting, timestamp generation, and backend dispatch only occur for messages that pass the level check. The Log4C backend manages output routing, file rotation, and integration with system logging facilities.<\/p>\n\n\n\n
    Northbound integration is achieved through the rdk_logger.h<\/code> public header and the librdkloggers<\/code> shared library. Any RDK component \u2014 whether a Thunder plugin, a standalone daemon, or a user-space utility \u2014 links against this library and calls RDK_LOGGER_INIT()<\/code> once before issuing log messages. The RDK_LOGGER_INIT()<\/code> macro automatically resolves the correct configuration file using the three-tier priority chain.<\/p>\n\n\n\n
    Southbound integration is handled by the Log4C library. RDK Logger registers custom layout types (formatters) and custom appender types (output backends) with Log4C before calling log4c_init()<\/code>. The log4crc<\/code> XML file controls how Log4C wires these layouts and appenders to log categories. This design allows the output format and destination to be changed by modifying log4crc<\/code> rather than recompiling.<\/p>\n\n\n\n
    The runtime control IPC mechanism uses a UDP socket (port 12035, loopback broadcast 127.255.255.255<\/code>). When rdklogctrl<\/code> is invoked, it constructs a structured binary message with a \"COMC\"<\/code> signature, the target process name, the module name, and the new log level, then broadcasts it. Each running process that has initialized RDK Logger maintains a non-blocking UDP socket and calls rdk_dyn_log_process_pending_request()<\/code> to drain any pending control messages. The receiving side validates the signature, verifies the target process name against __progname<\/code>, and applies the level change atomically.<\/p>\n\n\n\n
    Data persistence for standard log messages is delegated to Log4C appenders configured in log4crc<\/code> (e.g., console\/syslog\/journal or Log4C file\/rolling-file appenders). RDK Logger itself does not maintain a separate configuration cache beyond the Log4C category priority state applied at startup. Milestone log entries are persisted directly to a flat log file via fopen<\/code>\/fprintf<\/code>. Onboarding log entries are appended to a separate file path and are suppressed once the device is marked as provisioned.<\/p>\n\n\n\n
    flowchart TD\n    subgraph RDKLoggerBoundary[\"RDK Logger (librdkloggers)\"]\n\n        subgraph PublicAPI[\"Public API Layer\"]\n            API[\"rdk_logger.h\\nRDK_LOG macro\\nrdk_logger_init\"]\n        end\n\n        subgraph InitSubsystem[\"Initialization Subsystem\"]\n            Init[\"rdk_logger_init.c\\nrdk_logger_ext_init\\nrdk_logger_deinit\"]\n        end\n\n        subgraph PrivateCore[\"Private Core (rdk_debug_priv.c)\"]\n            ConfigParser[\"Configuration Parser\\nrdk_logger_parse_config\"]\n            LevelFilter[\"Level Filter\\nlog4c_category_is_priority_enabled\"]\n            Formatter[\"Format Handlers\\nformat_plaintext \/ format_with_ts\\nformat_with_tid \/ format_detail_with_ts\"]\n            Appenders[\"Appender Backends\\nto_console \/ to_syslog\\nto_journal\\nrollingfile (built-in)\"]\n        end\n\n        subgraph DynControl[\"Runtime Control (rdk_dynamic_logger.c)\"]\n            UDPListener[\"UDP Listener\\nPort 12035\\nrdk_dyn_log_process_pending_request\"]\n        end\n\n        subgraph Subsystems[\"Logging Subsystems\"]\n            Milestone[\"Milestone Logger\\nrdk_logger_milestone.c\"]\n            Onboard[\"Onboarding Logger\\nrdk_logger_onboard.c\"]\n        end\n    end\n\n    subgraph Backend[\"System Backend\"]\n        Log4C[\"Log4C Library\"]\n        SysLog[\"syslog \/ systemd journal\"]\n        FileFS[\"Rolling File (filesystem)\"]\n        Console[\"Console stdout\/stderr\"]\n    end\n\n    subgraph Control[\"Runtime Control Tool\"]\n        rdklogctrl[\"rdklogctrl utility\\nUDP port 12035\"]\n    end\n\n    API --> Init\n    Init --> ConfigParser\n    Init --> UDPListener\n    API --> LevelFilter\n    LevelFilter --> Formatter\n    Formatter --> Appenders\n    Appenders --> Log4C\n    Log4C --> Console\n    Log4C --> SysLog\n    Log4C --> FileFS\n    UDPListener --> ConfigParser\n    rdklogctrl -->|UDP broadcast| UDPListener\n    Milestone --> FileFS\n    Onboard --> FileFS<\/pre><\/div>\n\n\n\n
    Threading Model<\/h3>\n\n\n\n
      \n
    • Threading Architecture<\/strong>: Multi-threaded (library \u2014 runs in the context of the client process threads)<\/li>\n\n\n\n
    • Main Thread \/ Client Application Thread<\/strong>: Issues RDK_LOG()<\/code> calls from arbitrary client threads. Mutex (gLoggingMutex<\/code>) serializes concurrent log message dispatch through the Log4C backend.<\/li>\n\n\n\n
    • Initialization Thread<\/strong>: The first caller of rdk_logger_init()<\/code> acquires gInitMutex<\/code> to run the one-time initialization sequence. Subsequent callers find isLogInited = true<\/code> and return immediately under the same mutex.<\/li>\n\n\n\n
    • UDP Control Path<\/strong>: The runtime control mechanism is non-blocking; rdk_dyn_log_process_pending_request()<\/code> uses select()<\/code> with a zero timeout and is called from within the client process’s own event loop or logging path. The runtime control path requires no dedicated listener thread.<\/li>\n\n\n\n
    • Synchronization<\/strong>: Two pthread_mutex_t<\/code> instances are used \u2014 gInitMutex<\/code> guards the initialization state flag and rdk_logger_ext_init<\/code> path; gLoggingMutex<\/code> guards extended initialization of per-module appenders. The main logging path relies on Log4C’s own thread safety for category priority checks.<\/li>\n\n\n\n
    • Async \/ Event Dispatch<\/strong>: All log messages are written synchronously within the calling thread. Runtime control updates apply immediately after rdk_dbg_priv_log_reconfig()<\/code> updates the Log4C category priority.<\/li>\n<\/ul>\n\n\n\n
      Platform and Integration Requirements<\/h3>\n\n\n\n
        \n
      • Build Dependencies<\/strong>: log4c >= 1.2.3<\/code> (mandatory, detected via PKG_CHECK_MODULES<\/code>); libglib-2.0<\/code> (mandatory, linked via $(GLIB_LIBS)<\/code> \/ $(GLIB_CFLAGS)<\/code> provided by the build environment); libsystemd >= 209<\/code> (optional, auto-detected via PKG_CHECK_MODULES<\/code>; enables systemd journal appender when present).<\/li>\n\n\n\n
      • Configuration Files<\/strong>: \/etc\/debug.ini<\/code> must exist as the default configuration file. \/opt\/debug.ini<\/code> and \/nvram\/debug.ini<\/code> are optional override paths. log4crc<\/code> must be installed at the location Log4C searches by default (typically \/etc\/log4crc<\/code> or the path set by LOG4C_RCPATH<\/code>) to configure appenders and layouts.<\/li>\n\n\n\n
      • Startup Order<\/strong>: RDK Logger must be initialized before any RDK middleware component that issues RDK_LOG()<\/code> calls. As a shared library, initialization occurs in-process at the time the first component calls RDK_LOGGER_INIT()<\/code>.<\/li>\n<\/ul>\n\n\n\n
        \n\n\n\n
        Component State Flow<\/h3>\n\n\n\n
        Initialization to Active State<\/h4>\n\n\n\n
        The component transitions through the following states during its lifecycle: Initializing<\/strong> (mutex acquired, check isLogInited<\/code> flag) \u2192 LoadingConfig<\/strong> (parse the selected debug.ini, populate Log4C category priorities) \u2192 InitializingBackend<\/strong> (register custom layouts and appenders, call log4c_init()<\/code>) \u2192 StartingDynamicControl<\/strong> (open UDP socket on port 12035, bind to 127.255.255.255<\/code>) \u2192 Active<\/strong> (processing RDK_LOG()<\/code> calls, servicing runtime control messages) \u2192 Shutdown<\/strong> (close UDP socket, release resources).<\/p>\n\n\n\n
        sequenceDiagram\n    participant App as RDK Component \/ Application\n    participant Logger as RDK Logger (rdk_logger_init)\n    participant PrivCore as Private Core (rdk_debug_priv)\n    participant Log4C as Log4C Backend\n    participant DynLog as Dynamic Logger (rdk_dyn_log_init)\n    participant FS as File System\n\n    App->>Logger: RDK_LOGGER_INIT()\n    Note over Logger: Check \/opt\/debug.ini via access()\n    Logger->>FS: access(DEBUG_INI_OVERRIDE_PATH_1)\n    alt \/opt\/debug.ini accessible\n        FS-->>Logger: File found\n        Logger->>PrivCore: rdk_dbg_priv_config(\"\/opt\/debug.ini\")\n    else Check \/nvram\/debug.ini\n        Logger->>FS: access(DEBUG_INI_OVERRIDE_PATH_2)\n        alt \/nvram\/debug.ini accessible\n            FS-->>Logger: File found\n            Logger->>PrivCore: rdk_dbg_priv_config(\"\/nvram\/debug.ini\")\n        else Use default\n            Logger->>PrivCore: rdk_dbg_priv_config(\"\/etc\/debug.ini\")\n        end\n    end\n\n    Note over PrivCore: rdk_dbg_priv_init() - register layouts and appenders, log4c_init()\n    PrivCore->>Log4C: log4c_layout_type_set (6 layout types)\n    PrivCore->>Log4C: log4c_appender_type_set (console, syslog, journal)\n    PrivCore->>Log4C: log4c_init()\n    Log4C-->>PrivCore: Backend initialized\n    PrivCore->>FS: fopen \/ fgets debug.ini\n    FS-->>PrivCore: Module level entries\n    Note over PrivCore: Set log4c category priorities per module\n    PrivCore-->>Logger: RDK_SUCCESS\n\n    Logger->>DynLog: rdk_dyn_log_init()\n    DynLog->>DynLog: socket(AF_INET, SOCK_DGRAM) bind port 12035\n    DynLog-->>Logger: UDP listener ready\n\n    Note over Logger: isLogInited = true\n    Logger-->>App: RDK_SUCCESS (Active)\n\n    loop Runtime\n        App->>Logger: RDK_LOG(level, module, format, ...)\n        Logger->>PrivCore: rdk_dbg_priv_log_msg()\n    end\n\n    App->>Logger: rdk_logger_deinit()\n    Logger->>DynLog: rdk_dyn_log_deinit()\n    DynLog->>DynLog: close UDP socket\n    Logger-->>App: RDK_SUCCESS<\/pre><\/div>\n\n\n\n
        Runtime State Changes<\/h4>\n\n\n\n
        State Change Triggers:<\/strong><\/p>\n\n\n\n
          \n
        • Module Log Level Change via rdklogctrl<\/strong>: When a valid UDP control message is received matching the process name and a recognized module name, rdk_dbg_priv_log_reconfig()<\/code> updates the Log4C category priority for that module immediately. Subsequent RDK_LOG()<\/code> calls for that module reflect the new level without any restart.<\/li>\n\n\n\n
        • Invalid Control Message<\/strong>: Messages that fail signature validation (\"COMC\"<\/code> check) or have a mismatched process name are discarded; out-of-range log levels are rejected and reported to stderr<\/code> by rdk_dyn_log_validate_component_name()<\/code>.<\/li>\n\n\n\n
        • Configuration File Not Found<\/strong>: If the selected debug.ini cannot be opened, rdk_logger_parse_config()<\/code> returns RDK_FAILURE<\/code>, initialization of RDK Logger fails, and isLogInited<\/code> remains false. Log messages issued before a successful initialization are suppressed.<\/li>\n<\/ul>\n\n\n\n
          Context Switching Scenarios:<\/strong><\/p>\n\n\n\n
            \n
          • Three-Tier Configuration Resolution<\/strong>: At startup, RDK_LOGGER_INIT()<\/code> checks \/opt\/debug.ini<\/code>, then \/nvram\/debug.ini<\/code>, then \/etc\/debug.ini<\/code>. The first accessible file is used exclusively; the others are not merged.<\/li>\n\n\n\n
          • Extended Initialization (rdk_logger_ext_init<\/code>)<\/strong>: A component may call rdk_logger_ext_init()<\/code> with an rdk_logger_ext_config_t<\/code> structure to register a specific module name with a dedicated appender, output type, format, and file policy. This is used for components that require a separate log file rather than the shared console or syslog output.<\/li>\n<\/ul>\n\n\n\n
            \n\n\n\n
            Call Flows<\/h3>\n\n\n\n
            Initialization Call Flow<\/h4>\n\n\n\n
            sequenceDiagram\n    participant App as RDK Component\n    participant Logger as rdk_logger_init\n    participant PrivCore as Private Core\n    participant Log4C as Log4C Backend\n    participant DynLog as rdk_dyn_log_init\n\n    App->>Logger: RDK_LOGGER_INIT() macro\n    Logger->>Logger: Acquire gInitMutex, check isLogInited\n    Logger->>PrivCore: rdk_dbg_priv_init()\n    PrivCore->>Log4C: Register 6 layout types and 3 appender types\n    PrivCore->>Log4C: log4c_init()\n    Log4C-->>PrivCore: Initialized (reads log4crc)\n    PrivCore-->>Logger: Init complete\n    Logger->>PrivCore: rdk_dbg_priv_config(configFile)\n    PrivCore->>PrivCore: fopen and parse debug.ini entries\n    PrivCore->>Log4C: log4c_category_set_priority per module\n    PrivCore-->>Logger: RDK_SUCCESS\n    Logger->>DynLog: rdk_dyn_log_init()\n    DynLog->>DynLog: socket and bind on port 12035\n    DynLog-->>Logger: Socket ready\n    Logger->>Logger: Set isLogInited true, release gInitMutex\n    Logger-->>App: RDK_SUCCESS<\/pre><\/div>\n\n\n\n
            Request Processing Call Flow<\/h4>\n\n\n\n
            RDK_LOG()<\/code> is an alias for rdk_logger_msg_printf()<\/code>. On every invocation the module and format pointer are validated before calling rdk_dbg_priv_log_msg()<\/code>. Inside rdk_dbg_priv_log_msg()<\/code>, the Log4C category priority check acts as the fast-path filter: if the level is not enabled for the module, the function returns without any formatting or I\/O.<\/p>\n\n\n\n
            sequenceDiagram\n    participant Client as RDK Component Thread\n    participant Macro as RDK_LOG macro\n    participant MsgPrintf as rdk_logger_msg_printf\n    participant PrivLog as rdk_dbg_priv_log_msg\n    participant Log4C as Log4C Backend\n    participant Output as Output Destination\n\n    Client->>Macro: RDK_LOG(level, module, format, ...)\n    Macro->>MsgPrintf: rdk_logger_msg_printf(level, module, format, args)\n    MsgPrintf->>MsgPrintf: Validate module and format pointers\n    MsgPrintf->>PrivLog: rdk_dbg_priv_log_msg(level, module, format, args)\n    PrivLog->>Log4C: log4c_category_is_priority_enabled(category, priority)\n    alt Level enabled for module\n        Log4C-->>PrivLog: Enabled\n        PrivLog->>PrivLog: vsnprintf into format buffer\n        PrivLog->>Log4C: log4c_category_vlog(cat, log4cPriority, format, args)\n        Log4C->>Output: Write formatted message (console\/syslog\/journal\/file)\n        Output-->>Log4C: Written\n        Log4C-->>PrivLog: Done\n        PrivLog-->>MsgPrintf: Return\n        MsgPrintf-->>Client: Return\n    else Level disabled (fast path)\n        Log4C-->>PrivLog: Disabled\n        PrivLog-->>MsgPrintf: Return (no-op)\n        MsgPrintf-->>Client: Return (no-op)\n    end<\/pre><\/div>\n\n\n\n
            Runtime Control Call Flow<\/h4>\n\n\n\n
            sequenceDiagram\n    participant Admin as Operator\n    participant Ctrl as rdklogctrl utility\n    participant UDP as UDP Socket (port 12035)\n    participant Listener as rdk_dyn_log_process_pending_request\n    participant Reconfig as rdk_dbg_priv_log_reconfig\n    participant Log4C as Log4C Category\n\n    Admin->>Ctrl: rdklogctrl myapp LOG.RDK.MODULE DEBUG\n    Ctrl->>Ctrl: Validate module name prefix and log level string\n    Ctrl->>UDP: sendto(127.255.255.255:12035, COMC-framed packet)\n    Note over Listener: Called from within target process event loop\n    Listener->>UDP: select() + recvfrom() \u2014 non-blocking\n    UDP-->>Listener: Binary control packet\n    Listener->>Listener: Verify COMC signature and sender == 127.0.0.1\n    Listener->>Listener: Match __progname against app_name field\n    Listener->>Reconfig: rdk_dbg_priv_log_reconfig(\"LOG.RDK.MODULE\", RDK_LOG_DEBUG)\n    Reconfig->>Log4C: log4c_category_set_priority(cat, LOG4C_PRIORITY_DEBUG)\n    Log4C-->>Reconfig: Priority updated\n    Reconfig-->>Listener: true (success)\n    Listener->>Listener: fprintf(stderr, \"Log level change ... success\")<\/pre><\/div>\n\n\n\n
            \n\n\n\n
            Internal Modules<\/h2>\n\n\n\n
            Module \/ Class<\/th>Description<\/th>Key Files<\/th><\/tr><\/thead>
            Core Logging API<\/code><\/td>Exposes the RDK_LOG<\/code> macro, initialization functions, and log level enumeration. Entry point for all RDK components.<\/td>include\/rdk_logger.h<\/code>, include\/rdk_debug.h<\/code><\/td><\/tr>
            Initialization Manager<\/code><\/td>Implements rdk_logger_init()<\/code>, rdk_logger_ext_init()<\/code>, and rdk_logger_deinit()<\/code>. Guards one-time initialization with a mutex. Receives external data through the debug.ini file path.<\/td>src\/rdk_logger_init.c<\/code><\/td><\/tr>
            Private Core<\/code><\/td>Implements Log4C backend integration, all six layout formatters, three custom appender backends (to_console<\/code>, to_syslog<\/code>, to_journal<\/code>) plus rolling file output via Log4C’s built-in rollingfile<\/code> appender, configuration file parsing (rdk_logger_parse_config<\/code>), module-level log category management, and the rdk_dbg_priv_log_msg<\/code> dispatch function.<\/td>src\/rdk_debug_priv.c<\/code>, src\/include\/rdk_debug_priv.h<\/code><\/td><\/tr>
            Debug Dispatch<\/code><\/td>Public-facing wrappers (rdk_logger_msg_printf<\/code>, rdk_dbg_MsgRaw<\/code>, rdk_logger_msg_vsprintf<\/code>) that validate parameters and forward to rdk_dbg_priv_log_msg<\/code>. Also provides rdk_logger_set_logLevel<\/code>, rdk_logger_enable_logLevel<\/code>, and rdk_logger_level_from_string<\/code>.<\/td>src\/rdk_debug.c<\/code><\/td><\/tr>
            Dynamic Logger<\/code><\/td>Implements the non-blocking UDP listener (port 12035) used for runtime log level control. Validates incoming \"COMC\"<\/code>-signed messages and calls rdk_dbg_priv_log_reconfig<\/code> on matched entries.<\/td>src\/rdk_dynamic_logger.c<\/code>, src\/include\/rdk_dynamic_logger.h<\/code><\/td><\/tr>
            Milestone Logger<\/code><\/td>Provides logMilestone(msg_code)<\/code> which appends a <code>:<uptime_ms><\/code> record to the milestones log file using CLOCK_MONOTONIC_RAW<\/code>. Receives external data through the msg_code<\/code> string argument.<\/td>src\/rdk_logger_milestone.c<\/code>, include\/rdk_logger_milestone.h<\/code><\/td><\/tr>
            Onboarding Logger<\/code><\/td>Provides rdk_logger_log_onboard(module, msg, ...)<\/code> for writing provisioning-phase log entries to a dedicated onboarding log file. Suppressed when \/nvram\/.device_onboarded<\/code> or \/nvram\/DISABLE_ONBOARD_LOGGING<\/code> exists.<\/td>src\/rdk_logger_onboard.c<\/code><\/td><\/tr>
            Runtime Control Utility<\/code><\/td>CLI tool (rdklogctrl<\/code>) that constructs and sends \"COMC\"<\/code>-framed UDP messages to change log levels in running processes. Also includes the milestone CLI tool (rdklogmilestone<\/code>) and the onboarding utility (rdk_logger_onboard_main<\/code>).<\/td>utils\/rdklogctrl.c<\/code>, utils\/rdklogmilestone.c<\/code>, utils\/rdk_logger_onboard_main.c<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            Component Interactions<\/h2>\n\n\n\n
            RDK Logger is a foundational library where all interactions flow inward \u2014 middleware components call into RDK Logger, and RDK Logger calls down into system libraries.<\/p>\n\n\n\n
            Interaction Matrix<\/h3>\n\n\n\n
            Target Component \/ Layer<\/th>Interaction Purpose<\/th>Key APIs \/ Topics<\/th><\/tr><\/thead>
            System & Platform Layers<\/strong><\/td><\/td><\/td><\/tr>
            Log4C Library<\/td>Backend log message formatting, routing, and file management<\/td>log4c_init()<\/code>, log4c_category_get()<\/code>, log4c_category_set_priority()<\/code>, log4c_category_log()<\/code><\/td><\/tr>
            syslog daemon<\/td>System-wide log integration<\/td>openlog()<\/code>, syslog()<\/code>, closelog()<\/code> \u2014 active when HAVE_SYSLOG_H<\/code> is defined<\/td><\/tr>
            systemd journal<\/td>Modern Linux logging integration<\/td>sd_journal_print()<\/code> \u2014 active when HAVE_SYSTEMD<\/code> is defined and libsystemd >= 209<\/code> is present<\/td><\/tr>
            File system<\/td>Configuration file parsing; milestone and onboarding log persistence<\/td>fopen()<\/code>, fgets()<\/code>, fprintf()<\/code> on \/etc\/debug.ini<\/code>, \/opt\/debug.ini<\/code>, \/nvram\/debug.ini<\/code>, milestone log, onboarding log<\/td><\/tr>
            UDP socket (loopback)<\/td>Runtime log level control from rdklogctrl<\/code><\/td>socket(AF_INET, SOCK_DGRAM)<\/code>, port 12035, 127.255.255.255<\/code> broadcast<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            Events Published<\/h3>\n\n\n\n
            RDK Logger operates as a logging service, receiving log messages and control commands from RDK components and routing output to configured destinations. The table below captures the operational signals it emits.<\/p>\n\n\n\n
            Signal<\/th>Destination<\/th>Trigger Condition<\/th><\/tr><\/thead>
            Log level change acknowledgment<\/td>stderr<\/code> of the target process<\/td>Valid rdklogctrl<\/code> message received and applied successfully<\/td><\/tr>
            Milestone record<\/td>\/opt\/logs\/rdk_milestones.log<\/code> or \/rdklogs\/logs\/rdk_milestones.log<\/code><\/td>logMilestone()<\/code> called by any component<\/td><\/tr>
            Onboarding record<\/td>\/rdklogs\/logs\/OnBoardingLog.txt.0<\/code><\/td>rdk_logger_log_onboard()<\/code> called before device provisioning is complete<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            IPC Flow Patterns<\/h3>\n\n\n\n
            Primary Logging Flow:<\/strong><\/p>\n\n\n\n
            sequenceDiagram\n    participant Component as RDK Component Thread\n    participant Logger as RDK Logger Library\n    participant Log4C as Log4C Backend\n    participant Dest as Output (console\/syslog\/journal\/file)\n\n    Component->>Logger: RDK_LOG(level, module, format, ...)\n    Logger->>Logger: Validate module and format pointers\n    Logger->>Log4C: Check priority enabled for module category\n    alt Level passes filter\n        Logger->>Logger: Format message (timestamp, module, level, TID)\n        Logger->>Log4C: log4c_category_vlog(category, priority, msg)\n        Log4C->>Dest: Write formatted record\n        Dest-->>Log4C: Written\n        Log4C-->>Logger: Complete\n        Logger-->>Component: Return\n    else Level filtered\n        Logger-->>Component: No-op return\n    end<\/pre><\/div>\n\n\n\n
            Runtime Control Flow:<\/strong><\/p>\n\n\n\n
            sequenceDiagram\n    participant Operator as Operator\n    participant Tool as rdklogctrl\n    participant Target as Target Process (RDK Logger UDP listener)\n\n    Operator->>Tool: rdklogctrl <process> LOG.RDK.<MODULE> <LEVEL>\n    Tool->>Tool: Validate module prefix and level string\n    Tool->>Target: UDP packet to 127.255.255.255:12035\n    Note over Target: rdk_dyn_log_process_pending_request() polled by process\n    Target->>Target: Verify COMC signature, sender IP, process name\n    Target->>Target: rdk_dbg_priv_log_reconfig(module, level)\n    Target->>Target: Log4C category priority updated immediately\n    Target-->>Tool: (stderr confirmation in target process)<\/pre><\/div>\n\n\n\n
            \n\n\n\n
            Implementation Details<\/h2>\n\n\n\n
            Key Implementation Logic<\/h3>\n\n\n\n
              \n
            • Initialization and Lifecycle Management<\/strong>: rdk_logger_init()<\/code> in src\/rdk_logger_init.c<\/code> serializes initialization using gInitMutex<\/code> and the isLogInited<\/code> flag to ensure idempotent behavior in multi-threaded environments. The initialization sequence calls rdk_dbg_priv_init()<\/code> to register layout and appender types with Log4C and invoke log4c_init()<\/code>, then calls rdk_dbg_priv_config()<\/code> to parse the debug.ini file and set category priorities, then rdk_dyn_log_init()<\/code> to open the UDP control socket.<\/li>\n\n\n\n
            • Configuration Parsing<\/strong>: rdk_logger_parse_config()<\/code> in src\/rdk_debug_priv.c<\/code> reads the debug.ini file line-by-line, skipping comments and lines without =<\/code>. For the LOG.RDK.DEFAULT<\/code> entry it sets the root LOG.RDK<\/code> category priority; for all other LOG.RDK.*<\/code> entries it calls log4c_category_get()<\/code> and log4c_category_set_priority()<\/code>. Whitespace trimming is applied to both name and value tokens before comparison. Level strings are parsed case-insensitively by rdk_logger_level_from_string()<\/code>.<\/li>\n\n\n\n
            • Log4C Layout and Appender Registration<\/strong>: Six layout types (format_plaintext<\/code>, format_with_ts<\/code>, format_with_tid<\/code>, format_with_ts_tid<\/code>, format_detail_with_ts<\/code>, format_detail_without_ts<\/code>) and three custom appender types (to_console<\/code>, to_syslog<\/code>, to_journal<\/code>) are registered in rdk_dbg_priv_init()<\/code> before log4c_init()<\/code> is called, so that the log4crc<\/code> XML configuration file can reference them by name. Rolling file output uses Log4C’s built-in rollingfile<\/code> appender type (referenced by name string via log4c_appender_type_get(\"rollingfile\")<\/code>) \u2014 it is not registered as a custom type. A legacy comcast_dated<\/code> layout alias is also registered for backward compatibility.<\/li>\n\n\n\n
            • Extended Initialization and File Logging<\/strong>: rdk_logger_ext_init()<\/code> accepts an rdk_logger_ext_config_t<\/code> structure specifying a module name, log level, output type (RDKLOG_OUTPUT_CONSOLE<\/code>, RDKLOG_OUTPUT_SYSLOG<\/code>, RDKLOG_OUTPUT_JOURNAL<\/code>, or RDKLOG_OUTPUT_FILE<\/code>), format type, and an optional rdk_LogOutput_File<\/code> file policy. When RDKLOG_OUTPUT_FILE<\/code> is selected, the rdk_LogOutput_File<\/code> structure must be populated with fileName<\/code> (log file prefix, max 64 chars), fileLocation<\/code> (directory path, max 256 chars), fileCountMax<\/code> (maximum number of rotating files), and fileSizeMax<\/code> (maximum size per file in bytes). This path, implemented in rdk_dbg_priv_ext_init()<\/code>, creates or retrieves a Log4C category and attaches a dedicated rollingfile<\/code> appender with a sizewin<\/code> rolling policy. File rolling closes the current appender before reconfiguring, preventing data loss. This mechanism is the primary means for components that require per-component log files on disk rather than shared console or system log output.<\/li>\n\n\n\n
            • Runtime Log Level Control<\/strong>: rdk_dyn_log_process_pending_request()<\/code> in src\/rdk_dynamic_logger.c<\/code> uses a non-blocking select()<\/code> call on the UDP socket to drain any pending control messages in a loop. Each message is validated for the \"COMC\"<\/code> signature and loopback source address before rdk_dyn_log_validate_component_name()<\/code> matches the target process name against __progname<\/code>. Validated messages invoke rdk_dbg_priv_log_reconfig()<\/code> which calls log4c_category_set_priority()<\/code> with the new level.<\/li>\n\n\n\n
            • Error Handling Strategy<\/strong>: If configuration file parsing fails, rdk_logger_init()<\/code> returns RDK_FAILURE<\/code> and writes a diagnostic message to printf<\/code>. When log4c_init()<\/code> encounters an error, rdk_dbg_priv_init()<\/code> writes a diagnostic message to stderr<\/code> and the process continues with category state unchanged. When the UDP socket cannot be bound, rdk_dyn_log_init()<\/code> writes a diagnostic to stderr<\/code> and the process continues with static log levels only. Onboarding log file write failures produce output on printf<\/code> as a fallback.<\/li>\n\n\n\n
            • Logging & Diagnostics<\/strong>: All RDK_LOG()<\/code> calls use the LOG.RDK.<MODULE><\/code> naming convention. The root category LOG.RDK<\/code> acts as the default parent for any module not explicitly listed in debug.ini<\/code>. RDK Logger itself writes internal diagnostic messages to stderr<\/code> (not through the RDK_LOG<\/code> path) to avoid recursion during initialization or error conditions.<\/li>\n<\/ul>\n\n\n\n
              \n\n\n\n
              Configuration<\/h2>\n\n\n\n
              Key Configuration Files<\/h3>\n\n\n\n
              Configuration File<\/th>Purpose<\/th>Override Mechanism<\/th><\/tr><\/thead>
              \/etc\/debug.ini<\/code><\/td>Default system-wide log level configuration for all LOG.RDK.*<\/code> modules. Installed by the build system (sysconf_DATA<\/code> in Makefile.am<\/code>).<\/td>Overridden at runtime by \/opt\/debug.ini<\/code> (highest priority) or \/nvram\/debug.ini<\/code> (second priority) when either file is accessible.<\/td><\/tr>
              \/opt\/debug.ini<\/code><\/td>Platform-specific or field override configuration. Takes highest priority in the RDK_LOGGER_INIT()<\/code> resolution chain.<\/td>Takes precedence over all other configuration files when present and readable.<\/td><\/tr>
              \/nvram\/debug.ini<\/code><\/td>Runtime-writable override for temporary or persistent log level changes that survive reboots. Checked when \/opt\/debug.ini<\/code> is not present.<\/td>Overridden by \/opt\/debug.ini<\/code> when present.<\/td><\/tr>
              log4crc<\/code><\/td>Log4C XML configuration file. Defines layout types, appender types, and category-to-appender bindings. Installed by the build system.<\/td>Log4C environment variable LOG4C_RCPATH<\/code> may redirect to an alternate file.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
              Key Configuration Parameters<\/h3>\n\n\n\n
              Parameter<\/th>Type<\/th>Default<\/th>Description<\/th><\/tr><\/thead>
              LOG.RDK.DEFAULT<\/code><\/td>string (log level)<\/td>INFO<\/code> (per debug.ini<\/code>)<\/td>Sets the log level for the root LOG.RDK<\/code> category. All modules not explicitly listed in debug.ini<\/code> inherit this level.<\/td><\/tr>
              LOG.RDK.<MODULE><\/code><\/td>string (log level)<\/td>Inherits LOG.RDK.DEFAULT<\/code><\/td>Sets the log level for a specific named module. Accepted values: FATAL<\/code>, ERROR<\/code>, WARNING<\/code>, NOTICE<\/code>, INFO<\/code>, DEBUG<\/code>, TRACE<\/code>, NONE<\/code>.<\/td><\/tr>
              DEBUG_CONF_FILE<\/code><\/td>compile-time string<\/td>\"debug.ini\"<\/code><\/td>Fallback configuration file name used when rdk_logger_init()<\/code> receives a NULL<\/code> path argument. Set via -DDEBUG_CONF_FILE<\/code> in librdkloggers_la_CFLAGS<\/code>.<\/td><\/tr>
              LOGMILESTONE<\/code><\/td>compile-time flag<\/td>Undefined (uses \/rdklogs\/logs\/<\/code>)<\/td>When defined at build time, milestone events are written to \/opt\/logs\/rdk_milestones.log<\/code> instead of \/rdklogs\/logs\/rdk_milestones.log<\/code>.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
              File Output Configuration<\/h3>\n\n\n\n
              Components that require output to rolling log files on disk use rdk_logger_ext_init()<\/code> with RDKLOG_OUTPUT_FILE<\/code> and populate an rdk_LogOutput_File<\/code> structure passed via the pFilePolicy<\/code> field of rdk_logger_ext_config_t<\/code>:<\/p>\n\n\n\n
              Field<\/th>Type<\/th>Description<\/th><\/tr><\/thead>
              fileName<\/code><\/td>char[64]<\/code><\/td>Log file name prefix. The rollingfile<\/code> appender appends a numeric suffix when rotating.<\/td><\/tr>
              fileLocation<\/code><\/td>char[256]<\/code><\/td>Directory path where log files are written (e.g., \/rdklogs\/logs\/<\/code>).<\/td><\/tr>
              fileCountMax<\/code><\/td>int8_t<\/code><\/td>Maximum number of rotating log files to retain. When 0, no size-based rotation policy is applied.<\/td><\/tr>
              fileSizeMax<\/code><\/td>int64_t<\/code><\/td>Maximum size in bytes per file before rotation. When 0 with a non-zero fileCountMax<\/code>, the default Log4C rolling size is used.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
              Passing a NULL<\/code> pFilePolicy<\/code> when RDKLOG_OUTPUT_FILE<\/code> is selected causes rdk_dbg_priv_ext_init()<\/code> to reject the configuration and write a diagnostic to stderr<\/code>.<\/p>\n\n\n\n
              Runtime Configuration<\/h3>\n\n\n\n
              Log levels for individual modules can be changed at runtime using the rdklogctrl<\/code> utility:<\/p>\n\n\n\n
              # Change log level for a module in a running process\nrdklogctrl <process_name> <module_name> <log_level>\n\n# Examples\nrdklogctrl myapp LOG.RDK.NETWORK DEBUG\nrdklogctrl mediaPlayer LOG.RDK.AAMP TRACE\nrdklogctrl wpeProcess LOG.RDK.THUNDER INFO\n\n# Disable all logging for a module\nrdklogctrl myapp LOG.RDK.NETWORK NONE\n\n# Available levels: FATAL, ERROR, WARN, NOTICE, INFO, DEBUG, TRACE, NONE<\/pre>\n\n\n\n
              Configuration Persistence<\/h3>\n\n\n\n
              Runtime log level changes applied through rdklogctrl<\/code> are in-memory only and are lost when the target process restarts. To persist a level change across restarts, the debug.ini<\/code> file at \/nvram\/debug.ini<\/code> or \/opt\/debug.ini<\/code> must be updated directly, as RDK Logger reads configuration only at initialization time.<\/p>\n","protected":false},"excerpt":{"rendered":"
              RDK Logger is a general-purpose logging framework for RDK middleware components across video and broadband […]<\/p>\n","protected":false},"author":28,"featured_media":0,"parent":9575,"menu_order":23,"comment_status":"open","ping_status":"closed","template":"","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"footnotes":""},"class_list":["post-9708","page","type-page","status-publish","hentry"],"yoast_head":"\nRDK Logger - RDK Documentation Portal | Documentation<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"RDK Logger - RDK Documentation Portal | Documentation\" \/>\n<meta property=\"og:description\" content=\"RDK Logger is a general-purpose logging framework for RDK middleware components across video and broadband […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/\" \/>\n<meta property=\"og:site_name\" content=\"RDK Documentation Portal | Documentation\" \/>\n<meta property=\"article:modified_time\" content=\"2026-08-07T10:55:27+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"11 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/\",\"name\":\"RDK Logger - RDK Documentation Portal | Documentation\",\"isPartOf\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\"},\"datePublished\":\"2022-06-21T13:53:04+00:00\",\"dateModified\":\"2026-08-07T10:55:27+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Documentation\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"RDK Broadband\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Components\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/\"},{\"@type\":\"ListItem\",\"position\":5,\"name\":\"RDK Logger\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/\",\"name\":\"RDK Documentation Portal | Documentation\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"RDK Logger - RDK Documentation Portal | Documentation","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/","og_locale":"en_US","og_type":"article","og_title":"RDK Logger - RDK Documentation Portal | Documentation","og_description":"RDK Logger is a general-purpose logging framework for RDK middleware components across video and broadband […]","og_url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/","og_site_name":"RDK Documentation Portal | Documentation","article_modified_time":"2026-08-07T10:55:27+00:00","twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/","url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/","name":"RDK Logger - RDK Documentation Portal | Documentation","isPartOf":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website"},"datePublished":"2022-06-21T13:53:04+00:00","dateModified":"2026-08-07T10:55:27+00:00","breadcrumb":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/logger\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":2,"name":"Documentation","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":3,"name":"RDK Broadband","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/"},{"@type":"ListItem","position":4,"name":"Components","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_broadband_documentation\/components\/"},{"@type":"ListItem","position":5,"name":"RDK Logger"}]},{"@type":"WebSite","@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website","url":"https:\/\/developer.rdkcentral.com\/documentation\/","name":"RDK Documentation Portal | Documentation","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"_links":{"self":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9708","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/users\/28"}],"replies":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/comments?post=9708"}],"version-history":[{"count":2,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9708\/revisions"}],"predecessor-version":[{"id":13010,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9708\/revisions\/13010"}],"up":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9575"}],"wp:attachment":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/media?parent=9708"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}