diff --git a/src/profiling/LabelsAndEventClasses.cpp b/src/profiling/LabelsAndEventClasses.cpp
index 42b4a9d..daf1992 100644
--- a/src/profiling/LabelsAndEventClasses.cpp
+++ b/src/profiling/LabelsAndEventClasses.cpp
@@ -52,8 +52,16 @@
     m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::WORKLOAD_EXECUTION));
 
 // Event Class GUIDs
+// Start of Life (SOL)
+std::string LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME("start_of_life");
+ProfilingStaticGuid LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME));
 ProfilingStaticGuid LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS(
     m_GuidGenerator.GenerateStaticId("ARMNN_PROFILING_SOL"));
+// End of Life (EOL)
+std::string LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME("end_of_life");
+ProfilingStaticGuid LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME));
 ProfilingStaticGuid LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS(
     m_GuidGenerator.GenerateStaticId("ARMNN_PROFILING_EOL"));
 
diff --git a/src/profiling/LabelsAndEventClasses.hpp b/src/profiling/LabelsAndEventClasses.hpp
index d79870f..13332ff 100644
--- a/src/profiling/LabelsAndEventClasses.hpp
+++ b/src/profiling/LabelsAndEventClasses.hpp
@@ -46,8 +46,14 @@
     ARMNN_DLLEXPORT static ProfilingStaticGuid WORKLOAD_EXECUTION_GUID;
 
     // Event Class GUIDs
+    // Start of Life (SOL)
     ARMNN_DLLEXPORT static ProfilingStaticGuid ARMNN_PROFILING_SOL_EVENT_CLASS;
+    ARMNN_DLLEXPORT static std::string ARMNN_PROFILING_SOL_EVENT_CLASS_NAME;
+    ARMNN_DLLEXPORT static ProfilingStaticGuid ARMNN_PROFILING_SOL_EVENT_CLASS_NAME_GUID;
+    // End of Life (EOL)
     ARMNN_DLLEXPORT static ProfilingStaticGuid ARMNN_PROFILING_EOL_EVENT_CLASS;
+    ARMNN_DLLEXPORT static std::string ARMNN_PROFILING_EOL_EVENT_CLASS_NAME;
+    ARMNN_DLLEXPORT static ProfilingStaticGuid ARMNN_PROFILING_EOL_EVENT_CLASS_NAME_GUID;
 
 private:
     static ProfilingGuidGenerator m_GuidGenerator;
diff --git a/src/profiling/ProfilingUtils.cpp b/src/profiling/ProfilingUtils.cpp
index d832237..2482e2c 100644
--- a/src/profiling/ProfilingUtils.cpp
+++ b/src/profiling/ProfilingUtils.cpp
@@ -755,6 +755,7 @@
 }
 
 TimelinePacketStatus WriteTimelineEventClassBinary(uint64_t profilingGuid,
+                                                   uint64_t nameGuid,
                                                    unsigned char* buffer,
                                                    unsigned int remainingBufferSize,
                                                    unsigned int& numberOfBytesWritten)
@@ -776,7 +777,7 @@
     uint32_t declId = 2;
 
     // Calculate the length of the data (in bytes)
-    unsigned int dataSize = uint32_t_size + uint64_t_size; // decl_id + Profiling GUID
+    unsigned int dataSize = uint32_t_size + (uint64_t_size * 2); // decl_id + Profiling GUID + Name GUID
 
     // Check whether the timeline binary fits in the given buffer
     if (dataSize > remainingBufferSize)
@@ -791,6 +792,8 @@
     WriteUint32(buffer, offset, declId);        // decl_id
     offset += uint32_t_size;
     WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
+    offset += uint64_t_size;
+    WriteUint64(buffer, offset, nameGuid); // Name GUID
 
     // Update the number of bytes written
     numberOfBytesWritten = dataSize;
diff --git a/src/profiling/ProfilingUtils.hpp b/src/profiling/ProfilingUtils.hpp
index 92ddfe3..9c7ad03 100644
--- a/src/profiling/ProfilingUtils.hpp
+++ b/src/profiling/ProfilingUtils.hpp
@@ -239,6 +239,7 @@
                                                           unsigned int& numberOfBytesWritten);
 
 TimelinePacketStatus WriteTimelineEventClassBinary(uint64_t profilingGuid,
+                                                   uint64_t nameGuid,
                                                    unsigned char* buffer,
                                                    unsigned int bufferSize,
                                                    unsigned int& numberOfBytesWritten);
diff --git a/src/profiling/SendTimelinePacket.cpp b/src/profiling/SendTimelinePacket.cpp
index db8a633..b749b5d 100644
--- a/src/profiling/SendTimelinePacket.cpp
+++ b/src/profiling/SendTimelinePacket.cpp
@@ -94,10 +94,11 @@
                                profilingGuid);
 }
 
-void SendTimelinePacket::SendTimelineEventClassBinaryPacket(uint64_t profilingGuid)
+void SendTimelinePacket::SendTimelineEventClassBinaryPacket(uint64_t profilingGuid, uint64_t nameGuid)
 {
     ForwardWriteBinaryFunction(WriteTimelineEventClassBinary,
-                               profilingGuid);
+                               profilingGuid,
+                               nameGuid);
 }
 
 void SendTimelinePacket::SendTimelineLabelBinaryPacket(uint64_t profilingGuid, const std::string& label)
diff --git a/src/profiling/SendTimelinePacket.hpp b/src/profiling/SendTimelinePacket.hpp
index d4ea2ff..b1bae04 100644
--- a/src/profiling/SendTimelinePacket.hpp
+++ b/src/profiling/SendTimelinePacket.hpp
@@ -39,7 +39,7 @@
     void SendTimelineEventBinaryPacket(uint64_t timestamp, std::thread::id threadId, uint64_t profilingGuid) override;
 
     /// Create and write a TimelineEventClassBinaryPacket from the parameters to the buffer.
-    void SendTimelineEventClassBinaryPacket(uint64_t profilingGuid) override;
+    void SendTimelineEventClassBinaryPacket(uint64_t profilingGuid, uint64_t nameGuid) override;
 
     /// Create and write a TimelineLabelBinaryPacket from the parameters to the buffer.
     void SendTimelineLabelBinaryPacket(uint64_t profilingGuid, const std::string& label) override;
diff --git a/src/profiling/TimelineUtilityMethods.cpp b/src/profiling/TimelineUtilityMethods.cpp
index b0ce998..306551b 100644
--- a/src/profiling/TimelineUtilityMethods.cpp
+++ b/src/profiling/TimelineUtilityMethods.cpp
@@ -31,49 +31,55 @@
 {
     // Send the "name" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::NAME_GUID,
-                                                        LabelsAndEventClasses::NAME_LABEL);
+                                                 LabelsAndEventClasses::NAME_LABEL);
 
     // Send the "type" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::TYPE_GUID,
-                                                        LabelsAndEventClasses::TYPE_LABEL);
+                                                 LabelsAndEventClasses::TYPE_LABEL);
 
     // Send the "index" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::INDEX_GUID,
-                                                        LabelsAndEventClasses::INDEX_LABEL);
+                                                 LabelsAndEventClasses::INDEX_LABEL);
 
     // Send the "backendId" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::BACKENDID_GUID,
-                                                        LabelsAndEventClasses::BACKENDID_LABEL);
+                                                 LabelsAndEventClasses::BACKENDID_LABEL);
 
     // Send the "layer" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::LAYER_GUID,
-                                                        LabelsAndEventClasses::LAYER);
+                                                 LabelsAndEventClasses::LAYER);
 
     // Send the "workload" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::WORKLOAD_GUID,
-                                                        LabelsAndEventClasses::WORKLOAD);
+                                                 LabelsAndEventClasses::WORKLOAD);
 
     // Send the "network" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::NETWORK_GUID,
-                                                        LabelsAndEventClasses::NETWORK);
+                                                 LabelsAndEventClasses::NETWORK);
 
     // Send the "connection" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::CONNECTION_GUID,
-                                                        LabelsAndEventClasses::CONNECTION);
+                                                 LabelsAndEventClasses::CONNECTION);
 
     // Send the "inference" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::INFERENCE_GUID,
-                                                        LabelsAndEventClasses::INFERENCE);
+                                                 LabelsAndEventClasses::INFERENCE);
 
     // Send the "workload_execution" label, this call throws in case of error
     timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
-                                                        LabelsAndEventClasses::WORKLOAD_EXECUTION);
+                                                 LabelsAndEventClasses::WORKLOAD_EXECUTION);
 
     // Send the "start of life" event class, this call throws in case of error
-    timelinePacket.SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
+    timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME_GUID,
+                                                 LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME);
+    timelinePacket.SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                                      LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME_GUID);
 
     // Send the "end of life" event class, this call throws in case of error
-    timelinePacket.SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
+    timelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME_GUID,
+                                                 LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME);
+    timelinePacket.SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                                      LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME_GUID);
 
     timelinePacket.Commit();
 }
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
index ff25604..20e1a9b 100644
--- a/src/profiling/test/ProfilingTestUtils.cpp
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -118,6 +118,7 @@
 }
 
 void VerifyTimelineEventClassBinaryPacketData(ProfilingGuid guid,
+                                              ProfilingGuid nameGuid,
                                               const unsigned char* readableData,
                                               unsigned int& offset)
 {
@@ -136,6 +137,10 @@
     uint64_t readProfilingGuid = ReadUint64(readableData, offset);
     BOOST_CHECK(readProfilingGuid == guid);
 
+    offset += uint64_t_size;
+    uint64_t readProfiilngNameGuid = ReadUint64(readableData, offset);
+    BOOST_CHECK(readProfiilngNameGuid == nameGuid);
+
     // Update the offset to allow parsing to be continued after this function returns
     offset += uint64_t_size;
 }
diff --git a/src/profiling/test/ProfilingTestUtils.hpp b/src/profiling/test/ProfilingTestUtils.hpp
index 7e4f399..2e7daab 100644
--- a/src/profiling/test/ProfilingTestUtils.hpp
+++ b/src/profiling/test/ProfilingTestUtils.hpp
@@ -33,6 +33,7 @@
                                          unsigned int& offset);
 
 void VerifyTimelineEventClassBinaryPacketData(ProfilingGuid guid,
+                                              ProfilingGuid nameGuid,
                                               const unsigned char* readableData,
                                               unsigned int& offset);
 
diff --git a/src/profiling/test/SendTimelinePacketTests.cpp b/src/profiling/test/SendTimelinePacketTests.cpp
index 6d5bf49..05a6db8 100644
--- a/src/profiling/test/SendTimelinePacketTests.cpp
+++ b/src/profiling/test/SendTimelinePacketTests.cpp
@@ -144,7 +144,9 @@
     sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);
 
     const uint64_t eventClassBinaryPacketProfilingGuid = 789123u;
-    sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassBinaryPacketProfilingGuid);
+    const uint64_t eventClassBinaryPacketNameGuid = 8845u;
+    sendTimelinePacket->SendTimelineEventClassBinaryPacket(
+        eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid);
 
     // Commit the messages
     sendTimelinePacket->Commit();
@@ -178,7 +180,7 @@
     uint32_t entityBinaryPacketDataLength       = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
 
     BOOST_CHECK(entityBinaryPacketSequenceNumbered == 0);
-    BOOST_CHECK(entityBinaryPacketDataLength       == 24);
+    BOOST_CHECK(entityBinaryPacketDataLength       == 32);
 
     // Check the decl_id
     offset += uint32_t_size;
@@ -203,6 +205,10 @@
     readProfilingGuid = ReadUint64(packetBuffer, offset);
     BOOST_CHECK(readProfilingGuid == eventClassBinaryPacketProfilingGuid);
 
+    offset += uint64_t_size;
+    uint64_t readEventClassNameGuid = ReadUint64(packetBuffer, offset);
+    BOOST_CHECK(readEventClassNameGuid == eventClassBinaryPacketNameGuid);
+
     bufferManager.MarkRead(packetBuffer);
 }
 
@@ -263,7 +269,9 @@
 
     // Send TimelineEventClassBinaryPacket
     const uint64_t eventClassBinaryPacketProfilingGuid = 789123u;
-    sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassBinaryPacketProfilingGuid);
+    const uint64_t eventClassBinaryPacketNameGuid = 8845u;
+    sendTimelinePacket->SendTimelineEventClassBinaryPacket(
+        eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid);
 
     // Commit the buffer
     sendTimelinePacket->Commit();
@@ -291,7 +299,7 @@
     uint32_t eventClassBinaryPacketSequenceNumbered = (eventClassBinaryPacketHeaderWord1 >> 24) & 0x00000001;
     uint32_t eventClassBinaryPacketDataLength       = (eventClassBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
     BOOST_CHECK(eventClassBinaryPacketSequenceNumbered == 0);
-    BOOST_CHECK(eventClassBinaryPacketDataLength       == 12);
+    BOOST_CHECK(eventClassBinaryPacketDataLength       == 20);
 
     offset += uint32_t_size;
     uint32_t eventClassDeclId = ReadUint32(packetBuffer, offset);
@@ -302,6 +310,10 @@
     readProfilingGuid = ReadUint64(packetBuffer, offset);
     BOOST_CHECK(readProfilingGuid == eventClassBinaryPacketProfilingGuid);
 
+    offset += uint64_t_size;
+    uint64_t readEventClassNameGuid = ReadUint64(packetBuffer, offset);
+    BOOST_CHECK(readEventClassNameGuid == eventClassBinaryPacketNameGuid);
+
     bufferManager.MarkRead(packetBuffer);
 
     // Send TimelineEventBinaryPacket
@@ -388,7 +400,9 @@
 
     // Send TimelineEventClassBinaryPacket
     const uint64_t eventClassBinaryPacketProfilingGuid = 789123u;
-    BOOST_CHECK_THROW(sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassBinaryPacketProfilingGuid),
+    const uint64_t eventClassBinaryPacketNameGuid = 8845u;
+    BOOST_CHECK_THROW(sendTimelinePacket->SendTimelineEventClassBinaryPacket(
+                      eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid),
                       armnn::RuntimeException);
 }
 
diff --git a/src/profiling/test/TimelinePacketTests.cpp b/src/profiling/test/TimelinePacketTests.cpp
index 8cce520..555ec67 100644
--- a/src/profiling/test/TimelinePacketTests.cpp
+++ b/src/profiling/test/TimelinePacketTests.cpp
@@ -645,8 +645,10 @@
 BOOST_AUTO_TEST_CASE(TimelineEventClassTestNoBuffer)
 {
     const uint64_t profilingGuid = 123456u;
+    const uint64_t profilingNameGuid = 3345u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                profilingNameGuid,
                                                                 nullptr,
                                                                 512u,
                                                                 numberOfBytesWritten);
@@ -659,8 +661,10 @@
     std::vector<unsigned char> buffer(512, 0);
 
     const uint64_t profilingGuid = 123456u;
+    const uint64_t profilingNameGuid = 3345u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                profilingNameGuid,
                                                                 buffer.data(),
                                                                 0,
                                                                 numberOfBytesWritten);
@@ -673,8 +677,10 @@
     std::vector<unsigned char> buffer(10, 0);
 
     const uint64_t profilingGuid = 123456u;
+    const uint64_t profilingNameGuid = 5564u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                profilingNameGuid,
                                                                 buffer.data(),
                                                                 boost::numeric_cast<unsigned int>(buffer.size()),
                                                                 numberOfBytesWritten);
@@ -687,15 +693,18 @@
     std::vector<unsigned char> buffer(512, 0);
 
     const uint64_t profilingGuid = 123456u;
+    const uint64_t profilingNameGuid = 654321u;
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
+                                                                profilingNameGuid,
                                                                 buffer.data(),
                                                                 boost::numeric_cast<unsigned int>(buffer.size()),
                                                                 numberOfBytesWritten);
     BOOST_CHECK(result == TimelinePacketStatus::Ok);
-    BOOST_CHECK(numberOfBytesWritten == 12);
+    BOOST_CHECK(numberOfBytesWritten == 20);
 
     unsigned int uint32_t_size = sizeof(uint32_t);
+    unsigned int uint64_t_size = sizeof(uint64_t);
 
     unsigned int offset = 0;
     // Check the decl_id
@@ -706,6 +715,10 @@
     offset += uint32_t_size;
     uint64_t readProfilingGuid = ReadUint64(buffer.data(), offset);
     BOOST_CHECK(readProfilingGuid == profilingGuid);
+
+    offset += uint64_t_size;
+    uint64_t readProfilingNameGuid = ReadUint64(buffer.data(), offset);
+    BOOST_CHECK(readProfilingNameGuid == profilingNameGuid);
 }
 
 BOOST_AUTO_TEST_CASE(TimelineEventPacketTestNoBuffer)
diff --git a/src/profiling/test/TimelineUtilityMethodsTests.cpp b/src/profiling/test/TimelineUtilityMethodsTests.cpp
index 8fd8c36..815a3a0 100644
--- a/src/profiling/test/TimelineUtilityMethodsTests.cpp
+++ b/src/profiling/test/TimelineUtilityMethodsTests.cpp
@@ -82,7 +82,7 @@
     auto readableBuffer = mockBufferManager.GetReadableBuffer();
     BOOST_CHECK(readableBuffer != nullptr);
     unsigned int size = readableBuffer->GetSize();
-    BOOST_TEST(size == 300);
+    BOOST_TEST(size == 376);
     const unsigned char* readableData = readableBuffer->GetReadableData();
     BOOST_CHECK(readableData != nullptr);
 
@@ -90,7 +90,7 @@
     unsigned int offset = 0;
 
     // Verify Header
-    VerifyTimelineHeaderBinary(readableData, offset, 292);
+    VerifyTimelineHeaderBinary(readableData, offset, 368);
 
     // First "well-known" label: NAME
     VerifyTimelineLabelBinaryPacketData(LabelsAndEventClasses::NAME_GUID,
@@ -154,12 +154,24 @@
                                         offset);
 
     // First "well-known" event class: START OF LIFE
+    VerifyTimelineLabelBinaryPacketData(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME_GUID,
+                                        LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME,
+                                        readableData,
+                                        offset);
+
     VerifyTimelineEventClassBinaryPacketData(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                             LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS_NAME_GUID,
                                              readableData,
                                              offset);
 
     // Second "well-known" event class: END OF LIFE
+    VerifyTimelineLabelBinaryPacketData(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME_GUID,
+                                        LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME,
+                                        readableData,
+                                        offset);
+
     VerifyTimelineEventClassBinaryPacketData(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                             LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS_NAME_GUID,
                                              readableData,
                                              offset);
 
diff --git a/src/timelineDecoder/TimelineCaptureCommandHandler.cpp b/src/timelineDecoder/TimelineCaptureCommandHandler.cpp
index 6938911..9d1e8ee 100644
--- a/src/timelineDecoder/TimelineCaptureCommandHandler.cpp
+++ b/src/timelineDecoder/TimelineCaptureCommandHandler.cpp
@@ -89,6 +89,8 @@
     ITimelineDecoder::EventClass eventClass;
     eventClass.m_Guid = profiling::ReadUint64(data, offset);
     offset += uint64_t_size;
+    eventClass.m_NameGuid = profiling::ReadUint64(data, offset);
+    offset += uint64_t_size;
     m_TimelineDecoder.CreateEventClass(eventClass);
 }
 
diff --git a/src/timelineDecoder/tests/TimelineTests.cpp b/src/timelineDecoder/tests/TimelineTests.cpp
index 390b589..8d0b8a0 100644
--- a/src/timelineDecoder/tests/TimelineTests.cpp
+++ b/src/timelineDecoder/tests/TimelineTests.cpp
@@ -168,6 +168,7 @@
 
     const uint64_t entityGuid = 111111u;
     const uint64_t eventClassGuid = 22222u;
+    const uint64_t eventClassNameGuid = 22322u;
     const uint64_t timestamp = 33333u;
     const uint64_t eventGuid = 44444u;
 
@@ -205,7 +206,7 @@
                                            timelineCaptureCommandHandler);
 
         // Send event class
-        sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassGuid);
+        sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassGuid, eventClassNameGuid);
         sendTimelinePacket->Commit();
         SendTimelinePacketToCommandHandler(bufferManager.GetReadableBuffer()->GetReadableData(),
                                            timelineCaptureCommandHandler);
@@ -278,10 +279,11 @@
     BOOST_CHECK(timelineDecoder.SetLabelCallback(PushLabel) == Status::TimelineStatus_Success);
     BOOST_CHECK(timelineDecoder.SetRelationshipCallback(PushRelationship) == Status::TimelineStatus_Success);
 
-    const uint64_t entityGuid     = 111111u;
-    const uint64_t eventClassGuid = 22222u;
-    const uint64_t timestamp      = 33333u;
-    const uint64_t eventGuid      = 44444u;
+    const uint64_t entityGuid         = 111111u;
+    const uint64_t eventClassGuid     = 22222u;
+    const uint64_t eventClassNameGuid = 22322u;
+    const uint64_t timestamp          = 33333u;
+    const uint64_t eventGuid          = 44444u;
 
     const std::thread::id threadId = std::this_thread::get_id();
 
@@ -316,7 +318,7 @@
         // Send entity
         sendTimelinePacket->SendTimelineEntityBinaryPacket(entityGuid);
         // Send event class
-        sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassGuid);
+        sendTimelinePacket->SendTimelineEventClassBinaryPacket(eventClassGuid, eventClassNameGuid);
         // Send event
         sendTimelinePacket->SendTimelineEventBinaryPacket(timestamp, threadId, eventGuid);
         // Send label