add stumpless_entry_to_string

Author: junyeong0619

include/stumpless/entry.h

@@ -123,6 +123,34 @@ struct stumpless_entry {
 #  endif
 };
 
+ /**
+  * Returns all  entry's elements in formatted string.
+  * The character buffer should be freed when no longer is needed by the caller.
+  *
+  * **Thread Safety: MT-Safe**
+  * This function is thread safe. A mutex is used to coordinate the read of the
+  * element with other accesses and modifications.
+  *
+  * **Async Signal Safety: AS-Unsafe lock heap**
+  * This function is not safe to call from signal handlers due to the use of a
+  * non-reentrant lock to coordinate access and the use of memory management
+  * functions to create the result.
+  *
+  * **Async Cancel Safety: AC-Unsafe lock heap**
+  * This function is not safe to call from threads that may be asynchronously
+  * cancelled, due to the use of a lock that could be left locked as well as
+  * memory management functions.
+  *
+  *
+  * @param entry The entry to get all elements
+  *
+  * @return The formatted string of each entry's elements. Each element is
+  * formatted as element="value" and joined by " , ".  And append each element's
+  * string by stumpless_element_to_string
+  */
+ STUMPLESS_PUBLIC_FUNCTION
+ char *stumpless_entry_to_string( const struct stumpless_entry *entry );
+
 /**
  * Adds an element to an entry. The element is appended to the end of the list
  * of elements in this entry.
@@ -1817,4 +1845,4 @@ vstumpless_set_entry_message( struct stumpless_entry *entry,
 #  ifdef __cplusplus
 }                               /* extern "C" */
 #  endif
-#endif                          /* __STUMPLESS_ENTRY_H */
+#endif                          /* __STUMPLESS_ENTRY_H */

src/entry.c

@@ -20,6 +20,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <string.h>
+#include <stdlib.h>
 #include <stumpless/element.h>
 #include <stumpless/entry.h>
 #include <stumpless/facility.h>
@@ -1483,3 +1484,117 @@ void
 unlock_entry( const struct stumpless_entry *entry ) {
   config_unlock_mutex( entry->mutex );
 }
+
+/*
+ * static function for stumpless_entry_to_string
+ *  @param dest string to append formatted string
+ *  @param size_t offset dest's offset
+ *  @param key,value it is formatted to key="value",
+ *  @return updated offset
+ */
+static size_t append_key_value_pair(char *dest, size_t offset, const char *key, size_t key_length, const char *value, size_t value_length) {
+  // key="
+  memcpy(dest + offset, key, key_length);
+  offset += key_length;
+  dest[offset++] = '=';
+  dest[offset++] = '"';
+
+  // value
+    memcpy(dest + offset, value, value_length);
+    offset += value_length;
+
+
+  // "
+  dest[offset++] = '"';
+  dest[offset++] = ',';
+
+  return offset;
+}
+
+char *stumpless_entry_to_string(const struct stumpless_entry *entry) {
+    VALIDATE_ARG_NOT_NULL(entry);
+
+    lock_entry(entry);
+
+    const char *app_name = entry->app_name;
+    size_t app_name_length = entry->app_name_length;
+    struct stumpless_element **elements = entry->elements;
+    size_t elements_count = entry->element_count;
+    const char *hostname = entry->hostname;
+    size_t hostname_length = entry->hostname_length;
+    char *message = entry->message;
+    size_t message_length = entry->message_length;
+    const char *message_id = entry->msgid;
+    size_t message_id_length = entry->msgid_length;
+    const char *process_id = entry->procid;
+    size_t process_id_length = entry->procid_length;
+    size_t entry_priority_value = entry->prival;
+
+    size_t format_total_length = 0;
+
+    format_total_length += 7 + 20; // "prival=" + entry_priority_value
+    format_total_length += 9 + app_name_length; // "app_name="
+    format_total_length += 10 + hostname_length; // "hostname="
+    format_total_length += 12 + message_id_length; // "message_id="
+    format_total_length += 12 + process_id_length; // "process_id="
+    format_total_length += 9 + message_length; // "message="
+
+    for (size_t i = 0; i < elements_count; i++) {
+        const char *element_str = stumpless_element_to_string(elements[i]);
+        if (element_str) {
+            format_total_length += strlen(element_str) + 1; // +1 for comma
+            free_mem(element_str);
+        }
+    }
+
+    char *return_format = alloc_mem(format_total_length+1);
+    if (!return_format) {
+        return NULL;
+    }
+
+    size_t offset = 0;
+    char temp[21];
+
+  // prival
+  sprintf(temp, "%zu", entry_priority_value);
+  offset = append_key_value_pair(return_format, offset, "prival", strlen("prival"), temp, strlen(temp));
+
+  // app_name
+  offset = append_key_value_pair(return_format, offset, "app_name", strlen("app_name"), app_name, app_name_length);
+
+  // hostname
+  offset = append_key_value_pair(return_format, offset, "hostname", strlen("hostname"), hostname, hostname_length);
+
+  // message_id
+  offset = append_key_value_pair(return_format, offset, "message_id", strlen("message_id"), message_id, message_id_length);
+
+  // process_id
+  offset = append_key_value_pair(return_format, offset, "process_id", strlen("process_id"), process_id, process_id_length);
+
+  // message
+  offset = append_key_value_pair(return_format, offset, "message", strlen("message"), message, message_length);
+
+
+  bool is_first_element = true;
+  for (size_t i = 0; i < elements_count; i++) {
+    const char *element_str = stumpless_element_to_string(elements[i]);
+
+      size_t len = strlen(element_str);
+        if (!is_first_element) {
+          return_format[offset++] = ',';
+        }
+        memcpy(return_format + offset, element_str, len);
+        offset += len;
+        is_first_element = false;
+      free_mem(element_str);
+  }
+  unlock_entry(entry);
+
+  //erase , if no element
+  if(is_first_element) {
+    offset--;
+  }
+
+    return_format[offset] = '\0';
+    return return_format;
+}

src/windows/stumpless.def

@@ -259,3 +259,4 @@ EXPORTS
   stumpless_param_into_string                   @234
   stumpless_set_default_options                 @235
   stumpless_get_default_options                 @236
+  stumpless_entry_to_string                     @237

test/function/entry.cpp

@@ -97,6 +97,77 @@ namespace {
       }
   };
 
+  TEST_F( EntryTest, EntryToStringMallocFailure ) {
+    void * (*set_malloc_result)(size_t);
+    const char *result;
+
+    set_malloc_result = stumpless_set_malloc( MALLOC_FAIL );
+    ASSERT_NOT_NULL( set_malloc_result );
+
+    result = stumpless_entry_to_string(basic_entry);
+    EXPECT_ERROR_ID_EQ( STUMPLESS_MEMORY_ALLOCATION_FAILURE );
+    EXPECT_NULL( result );
+
+    set_malloc_result = stumpless_set_malloc( malloc );
+    EXPECT_TRUE( set_malloc_result == malloc );
+  }
+
+  TEST_F(EntryTest, OutputFormatCheck) {
+    char *result = stumpless_entry_to_string(basic_entry);
+    ASSERT_NE(result, nullptr);
+
+    const char *expected_output =
+      "prival=\"14\",app_name=\"basic-app-name\",hostname=\"\","
+      "message_id=\"basic-msgid\",process_id=\"\","
+      "message=\"basic message\","
+      "basic-element=[basic-param=\"basic-value\"],"
+      "basic-element-2";
+    EXPECT_STREQ(result, expected_output);
+    size_t len = strlen(result);
+    EXPECT_NE(result[len - 1], ',');
+    free(result);
+  }
+
+  TEST_F(EntryTest, LastCommaCheck) {
+    char *result = stumpless_entry_to_string(basic_entry);
+    ASSERT_NE(result, nullptr);
+
+    size_t len = strlen(result);
+    EXPECT_NE(result[len - 1], ',');
+
+    free(result);
+  }
+
+  TEST_F(EntryTest, NullEntry) {
+    char *result = stumpless_entry_to_string(NULL);
+    EXPECT_EQ(result, nullptr);
+    free(result);
+  }
+
+  TEST_F(EntryTest, EmptyHostnameAndProcid) {
+    char *result = stumpless_entry_to_string(basic_entry);
+    ASSERT_NE(result, nullptr);
+    EXPECT_TRUE(strstr(result, "hostname=\"\"") != nullptr);
+    EXPECT_TRUE(strstr(result, "process_id=\"\"") != nullptr);
+    EXPECT_TRUE(strstr(result, "message_id=\"basic-msgid\"") != nullptr);
+    free(result);
+  }
+
+  TEST_F(EntryTest, NoneOfElementCheck) {
+    struct stumpless_entry *test_entry = create_empty_entry();
+    char *result = stumpless_entry_to_string(test_entry);
+    ASSERT_NE(result, nullptr);
+
+    const char *expected_output =
+      "prival=\"14\",app_name=\"fixture-app-name\",hostname=\"\""
+      ",message_id=\"fixture-msgid\",process_id=\"\",message=\"fixture message\"";
+
+    EXPECT_STREQ(result, expected_output);
+
+    stumpless_destroy_entry_and_contents(test_entry);
+    free(result);
+  }
+
   TEST_F( EntryTest, AddElement ) {
     struct stumpless_entry *entry;
     struct stumpless_element *element;

tools/check_headers/stumpless.yml

@@ -428,6 +428,7 @@
 "stumpless_unset_option": "stumpless/target.h"
 "STUMPLESS_VERSION": "stumpless/config.h"
 "stumpless_version_to_string": "stumpless/version.h"
+"stumpless_entry_to_string": "stumpless/entry.h"
 "STUMPLESS_WEL_EVENT_ALERT": "stumpless/windows/default_events.h"
 "STUMPLESS_WEL_EVENT_CRITICAL": "stumpless/windows/default_events.h"
 "STUMPLESS_WEL_EVENT_DEBUG": "stumpless/windows/default_events.h"