3 Things To Know About Our Observability SDK

3 Things To Know About Our Observability SDK

More than meets the eye

AVIAD BUSKILA

September 28, 2022

If you are a Sternum user you certainly are aware of our Observability SDK that allows for monitoring and analysis of device-specific alerts, logs, metrics, and traces. The SDK is purpose-built for IoT devices and can be customized to provide accurate device-level information you need to maintain, secure, and enhance your unique products.

In this blog, I want to dive a bit deeper into some of the lesser-known facts about our SDK. But first, let's review what it does and how to deploy it.

SDK 101: An Easy Install Yields Powerful Insights


In a nutshell, the Observability SDK enables data collection and connectivity to the Sternum Cloud. As such, it has a dual function:

  1. It enables data collection, storage, and transmission.
  2. It can be configured to define what traces, logs and metrics are collected from the device and transmitted to the Cloud.

The SDK  is integrated through the following quick and easy process:

1. Import the library: Install the SDK into your firmware build or CI/CD system.

2.Initialize the SDK: Connect the SDK to the Sternum Cloud and synchronize it with the device

3. Define/customize your traces: Choose from dozens of predefined trace configurations or customize your own, to fit your unique device and monitoring strategy.

4. Send trace data: The inserted trace (see sample below) collects the data and the SDK sends the collected data to our Cloud for processing. In the case of gated or isolated devices, the SDK can also act as a proxy, storing data temporarily until the connection is available (more on that below).

STERNUM_ADS_TRACE(TRACE_TASK_STARTED,ARGUMENT_STRING(ARG_ROLE_NAME, 256, taskName))

5.View the trace results: Using our dashboard, you can view and analyze the data, gain insights into trends and emerging concerns, investigate alerts, inspect event timelines and more.

With the Observability SDK integrated, and the custom traces in place, users can access our platform and use the collected data for:

  • Security monitoring and investigation (e.g., IP addresses of incoming or outgoing connections)
  • Product performance monitoring and analysis (e.g., reboot, CPU or memory usage)
  • Device or application functional analysis (e.g., routing information or metrics indicating how users use the product)
  • Product troubleshooting (e.g., investigating a persistent dropped-connection issue)

Moreover, the trace data from SDK is also used to fuel our Anomaly Detection engine that uses the information to identify:

  • Communication pattern violations
  • Abnormal presence of an event or several events together
  • Absence of an event (e.g., an unfulfilled update request)
  • Abnormal amount of events (e.g., an abnormal amount of update requests)
  • Unusual value of a variable detection (e.g., unfamiliar entity connecting to internal IPC)
  • Atypical combination of values of several variables
  • Sequence violation (e.g., command execution w/o authentication)

Spotting these facilitates easy comparison of anomalies with the typical individual device behaviors. For instance, below you can see details of a failed update request that was auto-detected by the AI engine. This is an actual event, spotted in the first few days of the feature rollout. If missed, this could leave the device exposed to security and operational issues.

These automated insights allow fleet operators and engineers to spot troubles early, determine root causes more quickly, and identify hidden dependencies to help solve complex issues in less time and with fewer resources.


3 Things You Probably Didn’t Know

If you are using our SDK, you probably already have a good sense of its capabilities. Still, there are some deeper functionalities you may not be aware of. Here are my top three: 

 1. Optimized for efficiency

The Sternum Observability SDK is optimized for resource-restricted IoT devices (e.g., RTOS). Here are some design choices that make it particularly efficient: 

  • The SDK is coded in C, specifically for its low footprint and high-efficiency 
  • It uses TLS-only communication to ensure low resource utilization when encrypting and sending out data to our Cloud
  • It transfers data using a proprietary algorithm that delivers 3X the compression efficiency of alternatives we tested (before deciding to create our own solution)

2. Universally effective 

The Observability SDK acts as an abstraction layer between the device and the Sternum Cloud. This enables it to work with every device type and OS flavor (e.g., RTOS, Zephyr, Linux, Android, iOS, etc). Regardless of data type or format, the Sternum SDK ‘translates’ that data on its way to the Cloud, so it can be digested and analyzed, allowing you to monitor, track, and pull insights from whatever information you need. 

3. Acts as a proxy

IoT devices may be deployed in remote locations or with only intermittent connectivity. To support these deployment scenarios, the Observability SDK was built to act as a proxy, which allows it to be used for these various connectivity scenarios (fully connected, gateway connected, etc.) 

When in proxy mode, the SDK will collect and store data until a connection is established, at which point it will transfer the data to our Cloud for tracking, analysis, detection, etc.

Buy NOT Build

The concept of “Buy not Build” is a well-established one, and it holds true when it comes to IoT observability. 

Building an effective monitoring solution that provides all the relevant, granular information you need, for today and for the future, is a significant undertaking that requires a big commitment - both in terms of financial investment and developer time.

While organizations can develop their own DIY observability capabilities, it is unlikely they will be able to allocate enough resources to create something as mature and effective as a dedicated solution. 

At Sternum, we have built a mature and effective platform, which has been perfected over several years by a focused team of experts. The math is simple: the direct and indirect costs of attempting to build and maintain such a solution far outweigh the price of ownership of our platform. 

Interested in learning more? Want to see Sternum in action? Visit here to get your free demo

Better Performance with Autonomous Observability

Gain complete visibility by monitoring and analyzing events in your device or across an entire fleet, from the first line of code and until post-deployment maintenance.

Diagnose software bugs and vulnerabilities by using instrumentation, to pinpoint flaws, gain dynamic profiling and analysis of the software, including third-party code.

Learn about Sternum observability >>