Frequently Asked Questions

Integrating uLogger is a three-step process:

• Add the library – include the uLogger embedded C library in your build system (CMake, Make, or IDE project). A few files must be added and basic configuration entered to configure the library for your use-case.
• Initialize the agent – call ulogger_init(&config) with your device configuration at startup, before your application loop begins.
• Instrument your code – use the logging macros ulogger_log(POWER_MODULE, ULOG_INFO, "Battery voltage: %d mV", 3700) and ulogger_assert(packet_len < 128) at meaningful points throughout your firmware or application code. The agent compresses and queues messages automatically.
• Handle Hard Faults – the uLogger agent will automatically capture and log hard faults, providing detailed diagnostic information for debugging.

Full integration guides with step-by-step instructions and code examples for popular platforms are available in the documentation.

uLogger is designed to run across a broad range of embedded hardware and operating environments:

• ARM Cortex-M – STM32, nRF52, SAM/SAMD families and compatible microcontrollers
• Xtensa – ESP32 and ESP8266 (with Wi-Fi stack integration)
• RISC-V – GD32VF, SiFive, and compatible cores
• Linux-based systems – Raspberry Pi, industrial gateways, and embedded Linux (Yocto/Buildroot)

Yes. The uLogger embedded agent is purpose-built for resource-constrained devices. Key characteristics include:

• Under 4 KB flash footprint for the core library on ARM Cortex-M targets
• Minimal RAM usage – a configurable ring buffer with a static allocation option means no heap dependency
• Up to 90% log compression using binary encoding, dramatically reducing the data volume that must be stored or transmitted
• Negligible CPU overhead – logging calls are non-blocking and designed to complete in microseconds

uLogger is suitable for devices with as little as 64 KB of flash and 8 KB of RAM, making it viable for even the smallest Cortex-M0 and M0+ targets.

uLogger uses MQTT as its primary transport protocol — a lightweight publish/subscribe protocol designed for low-bandwidth, high-latency, and unreliable networks. Supported connectivity options include:

• LPWAN Options – Bluetooth, LoRa, Matter, Thread, and IEEE 802.15.4
• Wi-Fi (802.11 b/g/n) – ideal for indoor devices and development environments
• Ethernet – for fixed industrial and gateway deployments
• Cellular LTE / NB-IoT – for remote field deployments where Wi-Fi is unavailable

uLogger also supports store-and-forward operation: logs are buffered locally in non-volatile memory when the device is offline and automatically uploaded in batches once connectivity is restored. This ensures no diagnostic data is lost in intermittently connected deployments.

uLogger captures a rich set of diagnostic context automatically alongside each event:

• Timestamped log messages – severity-tagged messages from every layer of your firmware
• Crash reports & stack traces – full fault dumps including the call stack at the moment of failure
• CPU register state – register snapshot captured at the time of the fault for precise post-mortem analysis
• Heap & stack usage snapshots – memory utilization trends that reveal growth or exhaustion before a crash occurs
• Device metadata – firmware version, device ID, and hardware revision for fleet-wide correlation

All captured data is correlated and presented together in the uLogger cloud dashboard, enabling rapid root cause analysis without manual log correlation or file retrieval.

Without observability, embedded teams accumulate significant hidden technical debt: custom logging scripts, bespoke crash parsers, field retrieval processes, and one-off debugging sessions that never produce reusable tooling. uLogger replaces all of that with a single, structured platform:

• Eliminates ad-hoc debugging scripts – structured log capture and automatic crash symbolication replace hand-rolled parsing tools
• Reduces field escalations – real-time visibility into fleet behavior means issues surface before customers report them
• Accelerates root cause analysis – AI-assisted anomaly detection groups related failures across thousands of devices, surfacing patterns that would take days to find manually
• Shortens feedback loops – developers see the effect of firmware changes in the field within minutes of deployment, enabling faster iteration
• GitHub Copilot integration – uLogger can surface log context directly in your IDE, with AI-suggested fixes for common fault patterns

The result is a measurable reduction in mean time to resolution (MTTR), fewer regression bugs in subsequent releases, and a team that spends more time building features than chasing field failures.