Update Device Defender demo to send custom metrics

demos/defender/defender_demo_json/defender_demo.c

@@ -102,7 +102,15 @@
  * @brief Time in seconds to wait between retries of the demo loop if
  * demo loop fails.
  */
-#define DELAY_BETWEEN_DEMO_RETRY_ITERATIONS_S    ( 5 )
+#define DELAY_BETWEEN_DEMO_RETRY_ITERATIONS_S              ( 5 )
+
+/**
+ * @brief Number of custom metrics that will be sent to AWS IoT Device Defender service by
+ * the demo.
+ * This demo sends custom metrics for Cpu usage data (as number-list type) and memory data
+ * (as string-list type).
+ */
+#define NUMBER_OF_CUSTOM_METRICS_OBJECTS_IN_JSON_REPORT    ( 2 )
 
 /**
  * @brief Status values of the device defender report.
@@ -135,6 +143,12 @@ static uint16_t openUdpPorts[ OPEN_UDP_PORTS_ARRAY_SIZE ];
  */
 static Connection_t establishedConnections[ ESTABLISHED_CONNECTIONS_ARRAY_SIZE ];
 
+/**
+ * @brief Memory to represent custom metrics of CPU usage time and memory statistics
+ * that this demo sends to the AWS IoT Defender service.
+ */
+static CustomMetrics_t customMetrics;
+
 /**
  * @brief All the metrics sent in the device defender report.
  */
@@ -410,6 +424,32 @@ static bool collectDeviceMetrics( void )
         }
     }
 
+    /* Collect CPU usage time metrics from the system.
+     * This is an example of a custom metric of number-list type. */
+    if( metricsCollectorStatus == MetricsCollectorSuccess )
+    {
+        metricsCollectorStatus = GetCpuUsageStats( &customMetrics.cpuUsageStats );
+
+        if( metricsCollectorStatus != MetricsCollectorSuccess )
+        {
+            LogError( ( "Failed to get data of CPU usage from system. Status: %d.",
+                        metricsCollectorStatus ) );
+        }
+    }
+
+    /* Collect data on memory usage and calculate statistic on % of available memory
+     * in the system. This is an example of a custom metric of string-list type. */
+    if( metricsCollectorStatus == MetricsCollectorSuccess )
+    {
+        metricsCollectorStatus = GetMemoryStats( &customMetrics.memoryStats );
+
+        if( metricsCollectorStatus != MetricsCollectorSuccess )
+        {
+            LogError( ( "Failed to get data of memory statistics from system. Status: %d.",
+                        metricsCollectorStatus ) );
+        }
+    }
+
     /* Populate device metrics. */
     if( metricsCollectorStatus == MetricsCollectorSuccess )
     {
@@ -421,6 +461,7 @@ static bool collectDeviceMetrics( void )
         deviceMetrics.openUdpPortsArrayLength = numOpenUdpPorts;
         deviceMetrics.pEstablishedConnectionsArray = &( establishedConnections[ 0 ] );
         deviceMetrics.establishedConnectionsArrayLength = numEstablishedConnections;
+        deviceMetrics.pCustomMetrics = &customMetrics;
     }
 
     return status;

demos/defender/defender_demo_json/demo_config.h

@@ -42,7 +42,7 @@
 #endif
 
 #ifndef LIBRARY_LOG_LEVEL
-    #define LIBRARY_LOG_LEVEL    LOG_INFO
+    #define LIBRARY_LOG_LEVEL    LOG_DEBUG
 #endif
 
 #include "logging_stack.h"
@@ -194,10 +194,8 @@
 
 /**
  * @brief Size of the buffer which contains the generated device defender report.
- *
- * If the generated report is larger than this, it is rejected.
  */
-#define DEVICE_METRICS_REPORT_BUFFER_SIZE      1000
+#define DEVICE_METRICS_REPORT_BUFFER_SIZE      2000
 
 /**
  * @brief Major version number of the device defender report.

demos/defender/defender_demo_json/metrics_collector.c

@@ -36,8 +36,8 @@
 #include "metrics_collector.h"
 
 /**
- * @brief The maximum length of line read from any of /proc/net/dev, /proc/net/tcp
- * and /proc/net/udp.
+ * @brief The maximum length of line read from any of /proc/net/dev, /proc/net/tcp,
+ * /proc/net/udp, /proc/uptime and /proc/meminfo files.
  */
 #define MAX_LINE_LENGTH                  ( 256 )
 
@@ -378,4 +378,152 @@ MetricsCollectorStatus_t GetEstablishedConnections( Connection_t * pOutConnectio
 
     return status;
 }
+
+/*-----------------------------------------------------------*/
+
+MetricsCollectorStatus_t GetCpuUsageStats( CpuUsageStats_t * pCpuUsage )
+{
+    MetricsCollectorStatus_t status = MetricsCollectorSuccess;
+    FILE * fileHandle = NULL;
+    uint32_t filledVariables;
+    char lineBuffer[ MAX_LINE_LENGTH ];
+
+    if( pCpuUsage == NULL )
+    {
+        LogError( ( "Invalid parameter. pCpuUsage %p", ( void * ) pCpuUsage ) );
+        status = MetricsCollectorBadParameter;
+    }
+
+    if( status == MetricsCollectorSuccess )
+    {
+        fileHandle = fopen( "/proc/uptime", "r" );
+
+        if( fileHandle == NULL )
+        {
+            LogError( ( "Failed to open /proc/uptime." ) );
+            status = MetricsCollectorFileOpenFailed;
+        }
+    }
+
+    if( status == MetricsCollectorSuccess )
+    {
+        if( fgets( &( lineBuffer[ 0 ] ), MAX_LINE_LENGTH, fileHandle ) != NULL )
+        {
+            float upTime = 0.0f, idleTime = 0.0f;
+            LogDebug( ( "File: /proc/uptime, Content: %s.",
+                        &( lineBuffer[ 0 ] ) ) );
+
+            /* Parse the output. */
+            filledVariables = sscanf( &( lineBuffer[ 0 ] ),
+                                      "%f %f",
+                                      &( upTime ),
+                                      &( idleTime ) );
+
+            /* sscanf should fill all the 2 variables successfully. */
+            if( filledVariables != 2 )
+            {
+                LogError( ( "Failed to CPU usage data. File: /proc/uptime, Data: %s.", &( lineBuffer[ 0 ] ) ) );
+                status = MetricsCollectorParsingFailed;
+            }
+            else
+            {
+                /* Convert data from floating point to integer by multiplying by 100 to represent data in
+                 * USER_HZ time units. */
+                pCpuUsage->upTime = ( int64_t ) ( upTime * 100.0f );
+                pCpuUsage->idleTime = ( int64_t ) ( idleTime * 100.0f );
+            }
+        }
+    }
+
+    if( fileHandle != NULL )
+    {
+        fclose( fileHandle );
+    }
+
+    return status;
+}
 /*-----------------------------------------------------------*/
+
+MetricsCollectorStatus_t GetMemoryStats( MemoryStats_t * pMemoryData )
+{
+    MetricsCollectorStatus_t status = MetricsCollectorSuccess;
+    FILE * fileHandle = NULL;
+    /* Variables for reading and processing data from "/proc/meminfo" file. */
+    uint8_t lineNumber = 0;
+    char lineBuffer[ MAX_LINE_LENGTH ];
+    bool readTotalMem = false, readAvailableMem = false;
+    const char * const pTotalMemoryField = "MemTotal";
+    const char * const pAvailableMemField = "MemAvailable";
+    int filledVariables = 0;
+    uint64_t parsedMemData = 0UL;
+
+    if( ( pMemoryData == NULL ) )
+    {
+        LogError( ( "Invalid parameter. pMemoryData=%p", ( void * ) pMemoryData ) );
+        status = MetricsCollectorBadParameter;
+    }
+
+    if( status == MetricsCollectorSuccess )
+    {
+        fileHandle = fopen( "/proc/meminfo", "r" );
+
+        if( fileHandle == NULL )
+        {
+            LogError( ( "Failed to open /proc/meminfo." ) );
+            status = MetricsCollectorFileOpenFailed;
+        }
+    }
+
+    if( status == MetricsCollectorSuccess )
+    {
+        while( ( fgets( &( lineBuffer[ 0 ] ), MAX_LINE_LENGTH, fileHandle ) != NULL ) )
+        {
+            lineNumber++;
+
+            LogDebug( ( "File: /proc/meminfo, LineNo: %u, Content: %s.",
+                        lineNumber, &( lineBuffer[ 0 ] ) ) );
+
+            /* Extract the total memory value from the line. */
+            filledVariables = sscanf( lineBuffer,
+                                      "%*[^1-9]%lu kB",
+                                      ( &parsedMemData ) );
+
+            if( filledVariables != 1 )
+            {
+                LogError( ( "Failed to parse data. File: /proc/meminfo, Line:%d, Content:%s", lineNumber, lineBuffer ) );
+                status = MetricsCollectorParsingFailed;
+            }
+            /* Check if the line read represents information for "total memory" in the system. */
+            else if( strncmp( lineBuffer, pTotalMemoryField, strlen( pTotalMemoryField ) ) == 0 )
+            {
+                /* Populate buffer with information for total memory as "<data>kB". */
+                ( void ) snprintf( pMemoryData->totalMemory, sizeof( pMemoryData->totalMemory ),
+                                   "%lukB", parsedMemData );
+
+                readTotalMem = true;
+            }
+            /* Check if the line read represents information for "available memory" in the system. */
+            else if( strncmp( lineBuffer, pAvailableMemField, strlen( pAvailableMemField ) ) == 0 )
+            {
+                /* Populate buffer with information for total memory as "<data>kB". */
+                ( void ) snprintf( pMemoryData->availableMemory, sizeof( pMemoryData->availableMemory ),
+                                   "%lukB", parsedMemData );
+
+                readAvailableMem = true;
+            }
+
+            if( readTotalMem && readAvailableMem )
+            {
+                /* We have obtained data for both total and available memory in the system. */
+                break;
+            }
+        }
+    }
+
+    if( fileHandle != NULL )
+    {
+        fclose( fileHandle );
+    }
+
+    return status;
+}

demos/defender/defender_demo_json/metrics_collector.h

@@ -59,6 +59,28 @@ typedef struct Connection
     uint16_t remotePort;
 } Connection_t;
 
+/**
+ * @brief Represents the Cpu Usage statistics obtained from "/proc/uptime".
+ * Refer to Linux manual for "/proc" filesystem for more information.
+ * https://man7.org/linux/man-pages/man5/procfs.5.html
+ */
+typedef struct CpuUsageData
+{
+    uint32_t upTime;   /**< Up-time of system in USER_HZ (1/100th of second) time units. */
+    uint32_t idleTime; /**< Idle time of system in USER_HZ (1/100th of second) time units. */
+} CpuUsageStats_t;
+
+/**
+ * @brief Represents the memory data of total and available memory from "/proc/uptime".
+ * Refer to Linux manual for "/proc" filesystem for more information.
+ * https://man7.org/linux/man-pages/man5/procfs.5.html
+ */
+typedef struct MemoryStats
+{
+    char totalMemory[ 50 ];     /**< Amount of total memory in system (in kB). */
+    char availableMemory[ 50 ]; /**< Amount of available memory in system (in kB). */
+} MemoryStats_t;
+
 /**
  * @brief Get network stats.
  *
@@ -145,4 +167,35 @@ MetricsCollectorStatus_t GetEstablishedConnections( Connection_t * pOutConnectio
                                                     uint32_t connectionsArrayLength,
                                                     uint32_t * pOutNumEstablishedConnections );
 
+/**
+ * @brief Get CPU usage data of uptime and idle time from the system.
+ *
+ * This function finds the system CPU information by reading the "/proc/uptime" file.
+ *
+ * @param[out] pCpuUsage The memory to write the CPU usage statistics into.
+ *
+ * @return #MetricsCollectorSuccess if CPU usage data is successfully obtained;
+ * #MetricsCollectorBadParameter if invalid parameter is passed;
+ * #MetricsCollectorFileOpenFailed if the function fails to open "/proc/uptime";
+ * MetricsCollectorParsingFailed if the function fails to parses the data read
+ * from "/proc/uptime".
+ */
+MetricsCollectorStatus_t GetCpuUsageStats( CpuUsageStats_t * pCpuUsage );
+
+/**
+ * @brief Gets data of total and available memory in the system and populates them as
+ * key-value strings in the passed @p pMemoryData parameter.
+ *
+ * This function finds the memory information by reading the "/proc/meminfo" file.
+ *
+ * @param[out] pMemoryData The memory to write the memory information into.
+ *
+ * @return #MetricsCollectorSuccess if memory data statistic is successfully calculated;
+ * #MetricsCollectorBadParameter if invalid parameter is passed;
+ * #MetricsCollectorFileOpenFailed if the function fails to open "/proc/meminfo";
+ * MetricsCollectorParsingFailed if the function fails to parses the data read
+ * from "/proc/meminfo".
+ */
+MetricsCollectorStatus_t GetMemoryStats( MemoryStats_t * pMemoryData );
+
 #endif /* ifndef METRICS_COLLECTOR_H_ */