RDK-59221: Enable Accumulate Support For Grep Markers in Telemetry Profiles

source/dcautil/dca.c

@@ -547,7 +547,109 @@ static char* getAbsolutePatternMatch(FileDescriptor* fileDescriptor, const char*
     return result;
 }
 
-static int processPatternWithOptimizedFunction(const GrepMarker* marker, Vector* out_grepResultList, FileDescriptor* filedescriptor)
+static int getAccumulatePatternMatch(FileDescriptor* fileDescriptor, GrepMarker* marker, Vector* out_grepResultList)
+{
+    T2Info("%s ++in\n", __FUNCTION__);
+    if (!fileDescriptor || !fileDescriptor->cfaddr || fileDescriptor->cf_file_size <= 0 || !marker || !marker->searchString || !*marker->searchString || !out_grepResultList)
+    {
+        T2Error("Invalid file descriptor arguments accumulate\n");
+        return -1;
+    }
+
+    const char* pattern = marker->searchString;
+    const char* buffer;
+    size_t buflen = 0;
+    size_t patlen = strlen(pattern);
+
+    // Use the existing accumulatedValues Vector from marker's union
+    Vector* accumulatedValues = marker->u.accumulatedValues;
+    if (!accumulatedValues)
+    {
+        T2Error("accumulatedValues vector is NULL in marker\n");
+        return -1;
+    }
+
+    for (int i = 0; i < 2; i++)
+    {
+        T2Info("%s %d \n", __FUNCTION__, __LINE__);
+        if (i == 0)
+        {
+            buffer = fileDescriptor->cfaddr;
+            buflen = (size_t)fileDescriptor->cf_file_size;
+        }
+        else
+        {
+            buffer = fileDescriptor->rfaddr;
+            buflen = (size_t)fileDescriptor->rf_file_size;
+        }
+
+        if (buffer == NULL)
+        {
+            T2Info("Invalid file descriptor arguments accumulate match\n");
+            continue;
+        }
+
+        const char *cur = buffer;
+        size_t bytes_left = buflen;
+
+        while (bytes_left >= patlen)
+        {
+            T2Info("%s %d \n", __FUNCTION__, __LINE__);
+            const char *found = strnstr(cur, pattern, bytes_left);
+            if (!found)
+            {
+                break;
+            }
+
+            // Move pointer just after the pattern
+            const char *start = found + patlen;
+            size_t chars_left = buflen - (start - buffer);
+
+            // Find next newline or end of buffer
+            const char *end = memchr(start, '\n', chars_left);
+            size_t length = end ? (size_t)(end - start) : chars_left;
+
+            // Create result string for this occurrence
+            char *result = (char*)malloc(length + 1);
+            if (result)
+            {
+                memcpy(result, start, length);
+                result[length] = '\0';
+                T2Info("%s %d : result = %s\n", __FUNCTION__, __LINE__, result);
+                Vector_PushBack(accumulatedValues, result);
+            }
+
+            size_t advance = (size_t)(found - cur) + patlen;
+            cur = found + patlen;
+            if (bytes_left < advance)
+            {
+                break;
+            }
+            bytes_left -= advance;
+        }
+        T2Info("%s %d --out\n", __FUNCTION__, __LINE__);
+    }
+
+    // Create individual GrepResult objects for each accumulated value
+    size_t accumulatedCount = Vector_Size(accumulatedValues);
+    for (size_t j = 0; j < accumulatedCount; j++)
+    {
+        char* value = (char*)Vector_At(accumulatedValues, j);
+        if (value)
+        {
+            GrepResult* result = createGrepResultObj(marker->markerName, value, marker->trimParam, marker->regexParam);
+            if (result)
+            {
+                Vector_PushBack(out_grepResultList, result);
+            }
+        }
+    }
+
+    T2Debug("%s --out\n", __FUNCTION__);
+    return 0;
+}
+
+static int processPatternWithOptimizedFunction(GrepMarker* marker, Vector* out_grepResultList, FileDescriptor* filedescriptor)
 {
     // Sanitize the input
     const char* memmmapped_data_cf = filedescriptor->cfaddr;
@@ -583,7 +685,14 @@ static int processPatternWithOptimizedFunction(const GrepMarker* marker, Vector*
             Vector_PushBack(out_grepResultList, result);
         }
     }
-    else
+    else if (mType == MTYPE_ACCUMULATE)
+    {
+        //Get MAX_ACCUMULATE number of occurrences of the pattern in the memory-mapped data
+        T2Info("%s %d : Accumulate is called\n", __FUNCTION__, __LINE__);
+        getAccumulatePatternMatch(filedescriptor, marker, out_grepResultList);
+        T2Info("%s %d : Accumulate is complete\n", __FUNCTION__, __LINE__);
+    }
+    else /* MTYPE_ABSOLUTE */
     {
         // Get the last occurrence of the pattern in the memory-mapped data
         last_found = getAbsolutePatternMatch(filedescriptor, pattern);
@@ -655,7 +764,7 @@ static int getLogFileDescriptor(GrepSeekProfile* gsProfile, const char* logPath,
     // Check if the file size matches the seek value from the map
     if (sb.st_size == seek_value_from_map)
     {
-        T2Debug("The logfile size matches the seek value (%ld) for %s\n", seek_value_from_map, logFile);
+        T2Info("The logfile size matches the seek value (%ld) for %s\n", seek_value_from_map, logFile);
         close(fd);
         return -1; // Consistent error return value
     }

source/reportgen/reportgen.c

@@ -397,68 +397,204 @@ T2ERROR encodeGrepResultInJSON(cJSON *valArray, Vector *grepResult)
         T2Error("Invalid or NULL Arguments\n");
         return T2ERROR_INVALID_ARGS;
     }
-    size_t index = 0;
-    cJSON *arrayItem = NULL;
-    for(; index < Vector_Size(grepResult); index++)
+
+    // Create a hash map to group values by marker name
+    size_t totalResults = Vector_Size(grepResult);
+    if (totalResults == 0) {
+        T2Debug("%s --Out (no results)\n", __FUNCTION__);
+        return T2ERROR_SUCCESS;
+    }
+
+    // Simple approach: scan through all results and group by marker name
+    for (size_t i = 0; i < totalResults; i++)
     {
-        GrepResult* grep = (GrepResult *)Vector_At(grepResult, index);
-        if(grep)
+        GrepResult* grep = (GrepResult *)Vector_At(grepResult, i);
+        if(!grep || !grep->markerName || !grep->markerValue)
+        {
+            continue;
+        }
+
+        // Check if this marker name has already been processed
+        bool alreadyProcessed = false;
+        for (size_t j = 0; j < i; j++)
         {
-            if(grep->markerName == NULL || grep->markerValue == NULL ) // Ignore null values
+            GrepResult* prevGrep = (GrepResult *)Vector_At(grepResult, j);
+            if (prevGrep && prevGrep->markerName && strcmp(grep->markerName, prevGrep->markerName) == 0)
             {
-                continue ;
+                alreadyProcessed = true;
+                break;
             }
-            arrayItem = cJSON_CreateObject();
+        }
+
+        if (alreadyProcessed)
+        {
+            continue; // Skip this one, it's already been processed as part of a group
+        }
+
+        // Count how many results have the same marker name
+        Vector* sameMarkerResults = NULL;
+        Vector_Create(&sameMarkerResults);
+
+        for (size_t k = i; k < totalResults; k++)
+        {
+            GrepResult* currentGrep = (GrepResult *)Vector_At(grepResult, k);
+            if (currentGrep && currentGrep->markerName && currentGrep->markerValue && 
+                strcmp(grep->markerName, currentGrep->markerName) == 0)
+            {
+                Vector_PushBack(sameMarkerResults, currentGrep);
+            }
+        }
+
+        size_t sameMarkerCount = Vector_Size(sameMarkerResults);
+
+        if (sameMarkerCount == 1)
+        {
+            // Single result - use the original logic
+            GrepResult* singleGrep = (GrepResult *)Vector_At(sameMarkerResults, 0);
+            cJSON *arrayItem = cJSON_CreateObject();
             if(arrayItem == NULL)
             {
                 T2Error("cJSON_CreateObject failed..arrayItem is NULL \n");
+                Vector_Destroy(sameMarkerResults, NULL);
                 return T2ERROR_FAILURE;
             }
-            if(grep->trimParameter)
+
+            if(singleGrep->trimParameter)
             {
-                trimLeadingAndTrailingws((char*)grep->markerValue);
+                trimLeadingAndTrailingws((char*)singleGrep->markerValue);
             }
-            if(grep->regexParameter != NULL)
+
+            if(singleGrep->regexParameter != NULL)
             {
                 regex_t regpattern;
                 int rc = 0;
                 size_t nmatch = 1;
                 regmatch_t pmatch[2];
                 char string[256] = {'\0'};
-                rc = regcomp(&regpattern, grep->regexParameter, REG_EXTENDED);
+                rc = regcomp(&regpattern, singleGrep->regexParameter, REG_EXTENDED);
                 if(rc != 0)
                 {
                     T2Warning("regcomp() failed, returning nonzero (%d)\n", rc);
                 }
                 else
                 {
                     T2Debug("regcomp() successful, returning value (%d)\n", rc);
-                    rc = regexec(&regpattern, grep->markerValue, nmatch, pmatch, 0);
+                    rc = regexec(&regpattern, singleGrep->markerValue, nmatch, pmatch, 0);
                     if(rc != 0)
                     {
-                        T2Warning("regexec() failed, Failed to match '%s' with '%s',returning %d.\n", grep->markerValue, grep->regexParameter, rc);
-                        free((char*)grep->markerValue);
-                        grep->markerValue = strdup("");
+                        T2Warning("regexec() failed, Failed to match '%s' with '%s',returning %d.\n", singleGrep->markerValue, singleGrep->regexParameter, rc);
+                        free((char*)singleGrep->markerValue);
+                        singleGrep->markerValue = strdup("");
                     }
                     else
                     {
-                        T2Debug("regexec successful, Match is found %.*s\n", pmatch[0].rm_eo - pmatch[0].rm_so, &grep->markerValue[pmatch[0].rm_so]);
-                        sprintf(string, "%.*s", pmatch[0].rm_eo - pmatch[0].rm_so, &grep->markerValue[pmatch[0].rm_so]);
-                        free((char*)grep->markerValue);
-                        grep->markerValue = strdup(string);
+                        T2Debug("regexec successful, Match is found %.*s\n", pmatch[0].rm_eo - pmatch[0].rm_so, &singleGrep->markerValue[pmatch[0].rm_so]);
+                        sprintf(string, "%.*s", pmatch[0].rm_eo - pmatch[0].rm_so, &singleGrep->markerValue[pmatch[0].rm_so]);
+                        free((char*)singleGrep->markerValue);
+                        singleGrep->markerValue = strdup(string);
                     }
                     regfree(&regpattern);
                 }
             }
-            if(cJSON_AddStringToObject(arrayItem, grep->markerName, grep->markerValue)  == NULL)
+
+            if(cJSON_AddStringToObject(arrayItem, singleGrep->markerName, singleGrep->markerValue)  == NULL)
             {
                 T2Error("cJSON_AddStringToObject failed.\n");
                 cJSON_Delete(arrayItem);
+                Vector_Destroy(sameMarkerResults, NULL);
                 return T2ERROR_FAILURE;
             }
             cJSON_AddItemToArray(valArray, arrayItem);
         }
+        else if (sameMarkerCount > 1)
+        {
+            // Multiple results with same marker name - create JSON array
+            cJSON *arrayItem = cJSON_CreateObject();
+            if(arrayItem == NULL)
+            {
+                T2Error("cJSON_CreateObject failed..arrayItem is NULL \n");
+                Vector_Destroy(sameMarkerResults, NULL);
+                return T2ERROR_FAILURE;
+            }
+
+            cJSON *valuesArray = cJSON_CreateArray();
+            if(valuesArray == NULL)
+            {
+                T2Error("cJSON_CreateArray failed..valuesArray is NULL \n");
+                cJSON_Delete(arrayItem);
+                Vector_Destroy(sameMarkerResults, NULL);
+                return T2ERROR_FAILURE;
+            }
+
+            // Add all values to the array
+            for (size_t m = 0; m < sameMarkerCount; m++)
+            {
+                GrepResult* multiGrep = (GrepResult *)Vector_At(sameMarkerResults, m);
+                if (!multiGrep || !multiGrep->markerValue)
+                {
+                    continue;
+                }
+
+                char* processedValue = strdup(multiGrep->markerValue);
+                if (!processedValue)
+                {
+                    continue;
+                }
+
+                if(multiGrep->trimParameter)
+                {
+                    trimLeadingAndTrailingws(processedValue);
+                }
+
+                if(multiGrep->regexParameter != NULL)
+                {
+                    regex_t regpattern;
+                    int rc = 0;
+                    size_t nmatch = 1;
+                    regmatch_t pmatch[2];
+                    char string[256] = {'\0'};
+                    rc = regcomp(&regpattern, multiGrep->regexParameter, REG_EXTENDED);
+                    if(rc != 0)
+                    {
+                        T2Warning("regcomp() failed, returning nonzero (%d)\n", rc);
+                    }
+                    else
+                    {
+                        T2Debug("regcomp() successful, returning value (%d)\n", rc);
+                        rc = regexec(&regpattern, processedValue, nmatch, pmatch, 0);
+                        if(rc != 0)
+                        {
+                            T2Warning("regexec() failed, Failed to match '%s' with '%s',returning %d.\n", processedValue, multiGrep->regexParameter, rc);
+                            free(processedValue);
+                            processedValue = strdup("");
+                        }
+                        else
+                        {
+                            T2Debug("regexec successful, Match is found %.*s\n", pmatch[0].rm_eo - pmatch[0].rm_so, &processedValue[pmatch[0].rm_so]);
+                            sprintf(string, "%.*s", pmatch[0].rm_eo - pmatch[0].rm_so, &processedValue[pmatch[0].rm_so]);
+                            free(processedValue);
+                            processedValue = strdup(string);
+                        }
+                        regfree(&regpattern);
+                    }
+                }
+
+                cJSON *stringItem = cJSON_CreateString(processedValue);
+                if (stringItem != NULL)
+                {
+                    cJSON_AddItemToArray(valuesArray, stringItem);
+                }
+                free(processedValue);
+            }
+
+            // Add the array to the main object
+            cJSON_AddItemToObject(arrayItem, grep->markerName, valuesArray);
+            cJSON_AddItemToArray(valArray, arrayItem);
+        }
+
+        Vector_Destroy(sameMarkerResults, NULL);
     }
+
     T2Debug("%s --Out \n", __FUNCTION__);
     return T2ERROR_SUCCESS;
 }

source/t2parser/t2parser.c

@@ -1,6 +1,6 @@
 /*
  * If not stated otherwise in this file or this component's LICENSE file the
  * following copyright and licenses apply:
  *
  * Copyright 2019 RDK Management
  *
@@ -346,6 +346,16 @@
             gMarker->mType = MTYPE_COUNTER;
             gMarker->u.count = 0;
         }
+        else if (0 == strcmp(use, "accumulate"))
+        {
+            T2Info("marker type is Accumulate \n");
+            gMarker->mType = MTYPE_ACCUMULATE;
+            Vector_Create(&gMarker->u.accumulatedValues);
+            if(gMarker->reportTimestampParam == REPORTTIMESTAMP_UNIXEPOCH)
+            {
+                Vector_Create(&gMarker->accumulatedTimestamp);
+            }
+        }
         else
         {
             T2Info("Unsupported marker type. Defaulting to absolute \n");

source/utils/t2common.h

@@ -1,6 +1,6 @@
 /*
  * If not stated otherwise in this file or this component's LICENSE file the
  * following copyright and licenses apply:
  *
  * Copyright 2019 RDK Management
  *
@@ -95,13 +95,17 @@
     char* markerName;
     char* searchString;
     char* logFile;
+    reportTimestampFormat reportTimestampParam;
+    char* markerName_CT;
     char* regexParam;
     MarkerType mType;
     union
     {
         unsigned int count;
         char* markerValue;
+        Vector* accumulatedValues;
     } u;
+    Vector* accumulatedTimestamp;
     unsigned int skipFreq;
     int firstSeekFromEOF;
 } GrepMarker;