diff --git a/attn/attn_logging.cpp b/attn/attn_logging.cpp
index 014fc96..a55ac55 100644
--- a/attn/attn_logging.cpp
+++ b/attn/attn_logging.cpp
@@ -1,21 +1,421 @@
 #include <unistd.h>
 
 #include <attn/attn_logging.hpp>
+#include <attn/pel/pel_minimal.hpp>
 #include <phosphor-logging/log.hpp>
+
 namespace attn
 {
 
-/** @brief journal entry of type INFO using phosphor logging */
+/** @brief Journal entry of type INFO using phosphor logging */
 template <>
 void trace<INFO>(const char* i_message)
 {
     phosphor::logging::log<phosphor::logging::level::INFO>(i_message);
 }
 
-/** @brief add an event to the log for PEL generation */
-void event(EventType i_event, std::map<std::string, std::string>& i_additional)
+/** @brief Tuple containing information about ffdc files */
+using FFDCTuple =
+    std::tuple<util::FFDCFormat, uint8_t, uint8_t, sdbusplus::message::unix_fd>;
+
+/** @brief Gather messages from the journal */
+std::vector<std::string> sdjGetMessages(const std::string& field,
+                                        const std::string& fieldValue,
+                                        unsigned int max);
+
+/**
+ * Create FFDCTuple objects corresponding to the specified FFDC files.
+ *
+ * The D-Bus method to create an error log requires a vector of tuples to
+ * pass in the FFDC file information.
+ *
+ * @param   files - FFDC files
+ * @return  vector of FFDCTuple objects
+ */
+std::vector<FFDCTuple>
+    createFFDCTuples(const std::vector<util::FFDCFile>& files)
+{
+    std::vector<FFDCTuple> ffdcTuples{};
+    for (const util::FFDCFile& file : files)
+    {
+        ffdcTuples.emplace_back(
+            file.getFormat(), file.getSubType(), file.getVersion(),
+            sdbusplus::message::unix_fd(file.getFileDescriptor()));
+    }
+
+    return ffdcTuples;
+}
+
+/**
+ * @brief Create an FFDCFile object containing raw data
+ *
+ * Throws an exception if an error occurs.
+ *
+ * @param   i_buffer - raw data to add to ffdc faw data file
+ * @param   i_size - size of the raw data
+ * @return  FFDCFile object
+ */
+util::FFDCFile createFFDCRawFile(void* i_buffer, size_t i_size)
+{
+    util::FFDCFile file{util::FFDCFormat::Custom};
+
+    // Write buffer to file and then reset file description file offset
+    int fd = file.getFileDescriptor();
+    write(fd, static_cast<char*>(i_buffer), i_size);
+    lseek(fd, 0, SEEK_SET);
+
+    return file;
+}
+
+/**
+ * @brief Create an FFDCFile object containing the specified lines of text data
+ *
+ * Throws an exception if an error occurs.
+ *
+ * @param   lines - lines of text data to write to file
+ * @return  FFDCFile object
+ */
+util::FFDCFile createFFDCTraceFile(const std::vector<std::string>& lines)
+{
+    // Create FFDC file of type Text
+    util::FFDCFile file{util::FFDCFormat::Text};
+    int fd = file.getFileDescriptor();
+
+    // Write FFDC lines to file
+    std::string buffer;
+    for (const std::string& line : lines)
+    {
+        // Copy line to buffer.  Add newline if necessary.
+        buffer = line;
+        if (line.empty() || (line.back() != '\n'))
+        {
+            buffer += '\n';
+        }
+
+        // write buffer to file
+        write(fd, buffer.c_str(), buffer.size());
+    }
+
+    // Seek to beginning of file so error logging system can read data
+    lseek(fd, 0, SEEK_SET);
+
+    return file;
+}
+
+/**
+ * Create FDDC files from journal messages of relevant executables
+ *
+ * Parse the system journal looking for log entries created by the executables
+ * of interest for logging. For each of these entries create a ffdc trace file
+ * that will be used to create ffdc log entries. These files will be pushed
+ * onto the stack of ffdc files.
+ *
+ * @param   i_files - vector of ffdc files that will become log entries
+ */
+void createFFDCTraceFiles(std::vector<util::FFDCFile>& i_files)
+{
+    // Executables of interest
+    std::vector<std::string> executables{"openpower-hw-diags"};
+
+    for (const std::string& executable : executables)
+    {
+        try
+        {
+            // get journal messages
+            std::vector<std::string> messages =
+                sdjGetMessages("SYSLOG_IDENTIFIER", executable, 30);
+
+            // Create FFDC file containing the journal messages
+            if (!messages.empty())
+            {
+                i_files.emplace_back(createFFDCTraceFile(messages));
+            }
+        }
+        catch (const std::exception& e)
+        {
+            std::stringstream ss;
+            ss << "createFFDCFiles: " << e.what();
+            trace<level::INFO>(ss.str().c_str());
+        }
+    }
+}
+
+/**
+ * Create FFDCFile objects containing debug data to store in the error log.
+ *
+ * If an error occurs, the error is written to the journal but an exception
+ * is not thrown.
+ *
+ * @param   i_buffer - raw data (if creating raw dump ffdc entry in log)
+ * @return  vector of FFDCFile objects
+ */
+std::vector<util::FFDCFile> createFFDCFiles(char* i_buffer = nullptr,
+                                            size_t i_size  = 0)
+{
+    std::vector<util::FFDCFile> files{};
+
+    // Create raw dump file
+    if ((nullptr != i_buffer) && (0 != i_size))
+    {
+        files.emplace_back(createFFDCRawFile(i_buffer, i_size));
+    }
+
+    // Create trace dump file
+    createFFDCTraceFiles(files);
+
+    return files;
+}
+
+/**
+ * Get file descriptor of exisitng PEL
+ *
+ * The backend logging code will search for a PEL having the provided PEL ID
+ * and return a file descriptor to a file containing this PEL's  raw PEL data.
+ *
+ * @param  i_pelid - the PEL ID
+ * @return file descriptor of file containing the raw PEL data
+ */
+int getPelFd(uint32_t i_pelId)
+{
+    // GetPEL returns file descriptor (int)
+    int fd = -1;
+
+    // Sdbus call specifics
+    constexpr auto service   = "xyz.openbmc_project.Logging";
+    constexpr auto path      = "/xyz/openbmc_project/logging";
+    constexpr auto interface = "org.open_power.Logging.PEL";
+    constexpr auto function  = "GetPEL";
+
+    // Get the PEL file descriptor
+    try
+    {
+        auto bus    = sdbusplus::bus::new_default_system();
+        auto method = bus.new_method_call(service, path, interface, function);
+        method.append(i_pelId);
+
+        auto resp = bus.call(method);
+
+        sdbusplus::message::unix_fd msgFd;
+        resp.read(msgFd);
+        fd = dup(msgFd); // -1 if not found
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::stringstream ss;
+        ss << "getPelFd: " << e.what();
+        trace<level::INFO>(ss.str().c_str());
+    }
+
+    // File descriptor or -1 if not found or call failed
+    return fd;
+}
+
+/**
+ * Create a PEL for the specified event type
+ *
+ * The additional data provided in the map will be placed in a user data
+ * section of the PEL and may additionally contain key words to trigger
+ * certain behaviors by the backend logging code. Each set of data described
+ * in the vector of ffdc data will be placed in additional user data sections.
+ *
+ * @param  i_event - the event type
+ * @param  i_additional - map of additional data
+ * @param  9_ffdc - vector of ffdc data
+ * @return The created PEL's platform log-id
+ */
+uint32_t createPel(std::string i_event,
+                   std::map<std::string, std::string> i_additional,
+                   std::vector<util::FFDCTuple> i_ffdc)
+{
+    // CreatePELWithFFDCFiles returns log-id and platform log-id
+    std::tuple<uint32_t, uint32_t> pelResp = {0, 0};
+
+    // Sdbus call specifics
+    constexpr auto level     = "xyz.openbmc_project.Logging.Entry.Level.Error";
+    constexpr auto service   = "xyz.openbmc_project.Logging";
+    constexpr auto path      = "/xyz/openbmc_project/logging";
+    constexpr auto interface = "org.open_power.Logging.PEL";
+    constexpr auto function  = "CreatePELWithFFDCFiles";
+
+    // Need to provide pid when using create or create-with-ffdc methods
+    i_additional.emplace("_PID", std::to_string(getpid()));
+
+    // Create the PEL
+    try
+    {
+        auto bus    = sdbusplus::bus::new_default_system();
+        auto method = bus.new_method_call(service, path, interface, function);
+        method.append(i_event, level, i_additional, i_ffdc);
+
+        auto resp = bus.call(method);
+
+        resp.read(pelResp);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::stringstream ss;
+        ss << "createPel: " << e.what();
+        trace<level::INFO>(ss.str().c_str());
+    }
+
+    // pelResp<0> == log-id, pelResp<1> = platform log-id
+    return std::get<1>(pelResp);
+}
+
+/*
+ * Create a PEL from raw PEL data
+ *
+ * The backend logging code will create a PEL based on the specified PEL data.
+ *
+ * @param   i_buffer - buffer containing a raw PEL
+ */
+void createPelRaw(std::vector<uint8_t>& i_buffer)
+{
+    // Sdbus call specifics
+    constexpr auto event     = "xyz.open_power.Attn.Error.Terminate";
+    constexpr auto level     = "xyz.openbmc_project.Logging.Entry.Level.Error";
+    constexpr auto service   = "xyz.openbmc_project.Logging";
+    constexpr auto path      = "/xyz/openbmc_project/logging";
+    constexpr auto interface = "xyz.openbmc_project.Logging.Create";
+    constexpr auto function  = "Create";
+
+    // Create FFDC file from buffer data
+    util::FFDCFile pelFile{util::FFDCFormat::Text};
+    auto fd = pelFile.getFileDescriptor();
+
+    write(fd, i_buffer.data(), i_buffer.size());
+    lseek(fd, 0, SEEK_SET);
+
+    auto filePath = pelFile.getPath();
+
+    // Additional data for log
+    std::map<std::string, std::string> additional;
+    additional.emplace("RAWPEL", filePath.string());
+    additional.emplace("_PID", std::to_string(getpid()));
+
+    // Create the PEL
+    try
+    {
+        auto bus    = sdbusplus::bus::new_default_system();
+        auto method = bus.new_method_call(service, path, interface, function);
+        method.append(event, level, additional);
+        bus.call_noreply(method);
+    }
+    catch (const sdbusplus::exception::SdBusError& e)
+    {
+        std::stringstream ss;
+        ss << "createPelRaw: " << e.what();
+        trace<level::INFO>(ss.str().c_str());
+    }
+}
+
+/**
+ * Create a PEL from an existing PEL
+ *
+ * Create a new PEL based on the specified raw PEL and submit the new PEL
+ * to the backend logging code as a raw PEL. Note that  additional data map
+ * here contains data to be committed to the PEL and it can also be used to
+ * create the PEL as it contains needed information.
+ *
+ * @param   i_buffer - buffer containing a raw PEL
+ * @param   i_additional - additional data to be added to the new PEL
+ */
+void createPelCustom(std::vector<uint8_t>& i_rawPel,
+                     std::map<std::string, std::string> i_additional)
+{
+    // create PEL object from buffer
+    auto tiPel = std::make_unique<pel::PelMinimal>(i_rawPel);
+
+    // The additional data contains the TI info as well as the value for the
+    // subystem that provided the TI info. Get the subystem from additional
+    // data and then populate the prmary SRC and SRC words for the custom PEL
+    // based on the sybsystem's TI info.
+    uint8_t subsystem = std::stoi(i_additional["Subsystem"]);
+    tiPel->setSubsystem(subsystem);
+
+    if (static_cast<uint8_t>(pel::SubsystemID::hypervisor) == subsystem)
+    {
+        // populate hypervisor SRC words
+        tiPel->setSrcWords(std::array<uint32_t, pel::numSrcWords>{
+            (uint32_t)std::stoul(i_additional["0x10 SRC Word 12"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x14 SRC Word 13"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x18 SRC Word 14"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x1c SRC Word 15"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x20 SRC Word 16"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x24 SRC Word 17"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x28 SRC Word 18"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x2c SRC Word 19"], 0, 16)});
+
+        // populate hypervisor primary SRC
+        std::array<char, pel::asciiStringSize> srcChars{'0'};
+        std::string srcString = i_additional["SrcAscii"];
+        srcString.copy(srcChars.data(),
+                       std::min(srcString.size(), pel::asciiStringSize), 0);
+        tiPel->setAsciiString(srcChars);
+    }
+    else
+    {
+        // Populate hostboot SRC words - note HB word 0 from the shared info
+        // data (additional data "0x10 HB Word") is reflected in the PEL as
+        // "reason code" so we zero it here. Also note that the first word
+        // in this group of words starts at word 0 and word 1 does not exits.
+        tiPel->setSrcWords(std::array<uint32_t, pel::numSrcWords>{
+            (uint32_t)0x00000000,
+            (uint32_t)std::stoul(i_additional["0x14 HB Word 2"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x18 HB Word 3"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x1c HB Word 4"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x20 HB Word 5"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x24 HB Word 6"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x28 HB Word 7"], 0, 16),
+            (uint32_t)std::stoul(i_additional["0x2c HB Word 8"], 0, 16)});
+
+        // populate hostboot primary SRC
+        std::array<char, pel::asciiStringSize> srcChars{'0'};
+        std::string srcString = i_additional["0x30 error_data"];
+        srcString.copy(srcChars.data(),
+                       std::min(srcString.size(), pel::asciiStringSize), 0);
+        tiPel->setAsciiString(srcChars);
+    }
+
+    // set severity, event type and action flags
+    tiPel->setSeverity(static_cast<uint8_t>(pel::Severity::termination));
+    tiPel->setType(static_cast<uint8_t>(pel::EventType::na));
+    tiPel->setAction(static_cast<uint16_t>(pel::ActionFlags::service |
+                                           pel::ActionFlags::report |
+                                           pel::ActionFlags::call));
+
+    // The raw PEL that we used as the basis for this custom PEL contains the
+    // attention handler trace data and does not needed to be in this PEL so
+    // we remove it here.
+    tiPel->setSectionCount(tiPel->getSectionCount() - 1);
+
+    // Update the raw PEL with the new custom PEL data
+    tiPel->raw(i_rawPel);
+
+    // create PEL from raw data
+    createPelRaw(i_rawPel);
+}
+
+/**
+ * Log an event handled by the attention handler
+ *
+ * Basic (non TI) events will generate a standard message-registry based PEL
+ *
+ * TI events will create two PEL's. One PEL will be informational and will
+ * contain trace information relevent to attention handler. The second PEL
+ * will be specific to the TI type (including the primary SRC) and will be
+ * based off of the TI information provided to the attention handler through
+ * shared TI info data area.
+ *
+ * @param  i_event - The event type
+ * @param  i_additional - Additional PEL data
+ * @param  i_ffdc - FFDC PEL data
+ */
+void event(EventType i_event, std::map<std::string, std::string>& i_additional,
+           const std::vector<util::FFDCFile>& i_ffdc)
 {
     bool eventValid = false; // assume no event created
+    bool tiEvent    = false; // assume not a terminate event
 
     std::string eventName;
 
@@ -28,15 +428,13 @@
         case EventType::Terminate:
             eventName  = "org.open_power.Attn.Error.Terminate";
             eventValid = true;
+            tiEvent    = true;
             break;
         case EventType::Vital:
             eventName  = "org.open_power.Attn.Error.Vital";
             eventValid = true;
             break;
         case EventType::HwDiagsFail:
-            eventName  = "org.open_power.HwDiags.Error.Fail";
-            eventValid = true;
-            break;
         case EventType::AttentionFail:
             eventName  = "org.open_power.Attn.Error.Fail";
             eventValid = true;
@@ -48,93 +446,118 @@
 
     if (true == eventValid)
     {
-        // Get access to logging interface and method for creating log
-        auto bus = sdbusplus::bus::new_default_system();
+        // Create PEL with additional data and FFDC data. The newly created
+        // PEL's platform log-id will be returned.
+        auto pelId =
+            createPel(eventName, i_additional, createFFDCTuples(i_ffdc));
 
-        // using direct create method (for additional data)
-        auto method = bus.new_method_call(
-            "xyz.openbmc_project.Logging", "/xyz/openbmc_project/logging",
-            "xyz.openbmc_project.Logging.Create", "CreateWithFFDCFiles");
+        // If this is a TI event we will create an additional PEL that is
+        // specific to the subsystem that generated the TI.
+        if (true == tiEvent)
+        {
+            // get file descriptor and size of information PEL
+            int pelFd = getPelFd(pelId);
 
-        // Create FFDC files containing debug data to store in error log
-        std::vector<util::FFDCFile> files{createFFDCFiles()};
+            // if PEL found, read into buffer
+            if (-1 != pelFd)
+            {
+                auto pelSize = lseek(pelFd, 0, SEEK_END);
+                lseek(pelFd, 0, SEEK_SET);
 
-        // Create FFDC tuples used to pass FFDC files to D-Bus method
-        std::vector<FFDCTuple> ffdcTuples{createFFDCTuples(files)};
+                // read information PEL into buffer
+                std::vector<uint8_t> buffer(pelSize);
+                read(pelFd, buffer.data(), buffer.size());
+                close(pelFd);
 
-        // attach additional data
-        method.append(eventName,
-                      "xyz.openbmc_project.Logging.Entry.Level.Error",
-                      i_additional, ffdcTuples);
-
-        // log the event
-        bus.call_noreply(method);
+                // create PEL from buffer
+                createPelCustom(buffer, i_additional);
+            }
+        }
     }
 }
 
-/** @brief commit checkstop event to log */
+/** @brief Commit checkstop event to log */
 void eventCheckstop(std::map<std::string, std::string>& i_errors)
 {
+    // Additional data for log
     std::map<std::string, std::string> additionalData;
 
-    // TODO need multi-error/multi-callout stuff here
-
-    // if analyzer isolated errors
-    if (!(i_errors.empty()))
-    {
-        // FIXME TEMP CODE - begin
-
-        std::string signature = i_errors.begin()->first;
-        std::string chip      = i_errors.begin()->second;
-
-        additionalData["_PID"]      = std::to_string(getpid());
-        additionalData["SIGNATURE"] = signature;
-        additionalData["CHIP_ID"]   = chip;
-
-        // FIXME TEMP CODE -end
-
-        event(EventType::Checkstop, additionalData);
-    }
+    // Create log event with additional data and FFDC data
+    event(EventType::Checkstop, additionalData, createFFDCFiles(nullptr, 0));
 }
 
-/** @brief commit special attention TI event to log */
-void eventTerminate(std::map<std::string, std::string> i_additionalData)
+/**
+ * Commit special attention TI event to log
+ *
+ * Create a event log with provided additional information and standard
+ * FFDC data plus TI FFDC data
+ *
+ * @param i_additional - Additional log data
+ * @param i_ti_InfoData - TI FFDC data
+ */
+void eventTerminate(std::map<std::string, std::string> i_additionalData,
+                    char* i_tiInfoData)
 {
-    event(EventType::Terminate, i_additionalData);
+    // Create log event with aodditional data and FFDC data
+    event(EventType::Terminate, i_additionalData,
+          createFFDCFiles(i_tiInfoData, 0x53));
 }
 
-/** @brief commit SBE vital event to log */
+/** @brief Commit SBE vital event to log */
 void eventVital()
 {
+    // Additional data for log
     std::map<std::string, std::string> additionalData;
 
-    additionalData["_PID"] = std::to_string(getpid());
-
-    event(EventType::Vital, additionalData);
+    // Create log event with additional data and FFDC data
+    event(EventType::Vital, additionalData, createFFDCFiles(nullptr, 0));
 }
 
-/** @brief commit analyzer failure event to log */
+/**
+ * Commit analyzer failure event to log
+ *
+ * Create an event log containing the specified error code.
+ *
+ * @param i_error - Error code
+ */
 void eventHwDiagsFail(int i_error)
 {
+    // Additiona data for log
     std::map<std::string, std::string> additionalData;
-
-    additionalData["_PID"] = std::to_string(getpid());
-
-    event(EventType::HwDiagsFail, additionalData);
-}
-
-/** @brief commit attention handler failure event to log */
-void eventAttentionFail(int i_error)
-{
-    std::map<std::string, std::string> additionalData;
-
-    additionalData["_PID"]       = std::to_string(getpid());
     additionalData["ERROR_CODE"] = std::to_string(i_error);
 
-    event(EventType::AttentionFail, additionalData);
+    // Create log event with additional data and FFDC data
+    event(EventType::HwDiagsFail, additionalData, createFFDCFiles(nullptr, 0));
 }
 
-/** @brief parse systemd journal message field */
+/**
+ * Commit attention handler failure event to log
+ *
+ * Create an event log containing the specified error code.
+ *
+ * @param i_error - Error code
+ */
+void eventAttentionFail(int i_error)
+{
+    // Additional data for log
+    std::map<std::string, std::string> additionalData;
+    additionalData["ERROR_CODE"] = std::to_string(i_error);
+
+    // Create log event with additional data and FFDC data
+    event(EventType::AttentionFail, additionalData,
+          createFFDCFiles(nullptr, 0));
+}
+
+/**
+ * Parse systemd journal message field
+ *
+ * Parse the journal looking for the specified field and return the journal
+ * data for that field.
+ *
+ * @param  journal - The journal to parse
+ * @param  field - Field containing the data to retrieve
+ * @return Data for the speciefied field
+ */
 std::string sdjGetFieldValue(sd_journal* journal, const char* field)
 {
     const char* data{nullptr};
@@ -167,7 +590,17 @@
     }
 }
 
-/** @brief get messages from systemd journal */
+/**
+ * Gather messages from the journal
+ *
+ * Fetch journal entry data for all entries with the specified field equal to
+ * the specified value.
+ *
+ * @param   field - Field to search on
+ * @param   fieldValue -  Value to search for
+ * @param   max - Maximum number of messages fetch
+ * @return  Vector of journal entry data
+ */
 std::vector<std::string> sdjGetMessages(const std::string& field,
                                         const std::string& fieldValue,
                                         unsigned int max)
@@ -227,78 +660,4 @@
     return messages;
 }
 
-/** @brief create a file containing FFDC data */
-util::FFDCFile createFFDCFile(const std::vector<std::string>& lines)
-{
-    // Create FFDC file of type Text
-    util::FFDCFile file{util::FFDCFormat::Text};
-    int fd = file.getFileDescriptor();
-
-    // Write FFDC lines to file
-    std::string buffer;
-    for (const std::string& line : lines)
-    {
-        // Copy line to buffer.  Add newline if necessary.
-        buffer = line;
-        if (line.empty() || (line.back() != '\n'))
-        {
-            buffer += '\n';
-        }
-
-        // write buffer to file
-        write(fd, buffer.c_str(), buffer.size());
-    }
-
-    // Seek to beginning of file so error logging system can read data
-    lseek(fd, 0, SEEK_SET);
-
-    return file;
-}
-
-/** @brief Create FDDC files from journal messages of relevant executables */
-std::vector<util::FFDCFile> createFFDCFiles()
-{
-    std::vector<util::FFDCFile> files{};
-
-    // Executables of interest
-    std::vector<std::string> executables{"openpower-hw-diags"};
-
-    for (const std::string& executable : executables)
-    {
-        try
-        {
-            // get journal messages
-            std::vector<std::string> messages =
-                sdjGetMessages("SYSLOG_IDENTIFIER", executable, 30);
-
-            // Create FFDC file containing the journal messages
-            if (!messages.empty())
-            {
-                files.emplace_back(createFFDCFile(messages));
-            }
-        }
-        catch (const std::exception& e)
-        {
-            std::stringstream ss;
-            ss << "createFFDCFiles: " << e.what();
-            trace<level::INFO>(ss.str().c_str());
-        }
-    }
-
-    return files;
-}
-
-/** create tuples of FFDC files */
-std::vector<FFDCTuple> createFFDCTuples(std::vector<util::FFDCFile>& files)
-{
-    std::vector<FFDCTuple> ffdcTuples{};
-    for (util::FFDCFile& file : files)
-    {
-        ffdcTuples.emplace_back(
-            file.getFormat(), file.getSubType(), file.getVersion(),
-            sdbusplus::message::unix_fd(file.getFileDescriptor()));
-    }
-    return ffdcTuples;
-}
-
 } // namespace attn
diff --git a/attn/attn_logging.hpp b/attn/attn_logging.hpp
index 8b5feba..0103a52 100644
--- a/attn/attn_logging.hpp
+++ b/attn/attn_logging.hpp
@@ -29,58 +29,24 @@
 /** @brief Maximum length of a single trace event message */
 static const size_t trace_msg_max_len = 255;
 
-/** @brief create trace message */
+/** @brief Create trace message template */
 template <level L>
 void trace(const char* i_message);
 
-/** @brief commit checkstop event to log */
+/** @brief Commit checkstop event to log */
 void eventCheckstop(std::map<std::string, std::string>& i_errors);
 
-/** @brief commit special attention TI event to log */
-void eventTerminate(std::map<std::string, std::string> i_additionalData);
+/** @brief Commit special attention TI event to log */
+void eventTerminate(std::map<std::string, std::string> i_additionalData,
+                    char* i_tiInfoData);
 
-/** @brief commit SBE vital event to log */
+/** @brief Commit SBE vital event to log */
 void eventVital();
 
-/** @brief commit analyzer failure event to log */
+/** @brief Commit analyzer failure event to log */
 void eventHwDiagsFail(int i_error);
 
-/** @brief commit attention handler failure event to log */
+/** @brief Commit attention handler failure event to log */
 void eventAttentionFail(int i_error);
 
-using FFDCTuple =
-    std::tuple<util::FFDCFormat, uint8_t, uint8_t, sdbusplus::message::unix_fd>;
-
-/**
- * Create an FFDCFile object containing the specified lines of text data.
- *
- * Throws an exception if an error occurs.
- *
- * @param lines lines of text data to write to file
- * @return FFDCFile object
- */
-util::FFDCFile createFFDCFile(const std::vector<std::string>& lines);
-
-/**
- * Create FFDCFile objects containing debug data to store in the error log.
- *
- * If an error occurs, the error is written to the journal but an exception
- * is not thrown.
- *
- * @param journal system journal
- * @return vector of FFDCFile objects
- */
-std::vector<util::FFDCFile> createFFDCFiles();
-
-/**
- * Create FFDCTuple objects corresponding to the specified FFDC files.
- *
- * The D-Bus method to create an error log requires a vector of tuples to
- * pass in the FFDC file information.
- *
- * @param files FFDC files
- * @return vector of FFDCTuple objects
- */
-std::vector<FFDCTuple> createFFDCTuples(std::vector<util::FFDCFile>& files);
-
 } // namespace attn
diff --git a/attn/meson.build b/attn/meson.build
index 815e038..d42289d 100644
--- a/attn/meson.build
+++ b/attn/meson.build
@@ -37,6 +37,14 @@
     'vital_handler.cpp',
 )
 
+# for custom/raw PEL creation
+pel_src = files(
+    'pel/pel_minimal.cpp',
+    'pel/private_header.cpp',
+    'pel/primary_src.cpp',
+    'pel/user_header.cpp',
+)
+
 # Library dependencies.
 attn_deps = [
     libgpiod,
@@ -48,6 +56,7 @@
 attn_lib = static_library(
     'attn_lib',
     attn_src,
+    pel_src,
     include_directories : incdir,
     dependencies : attn_deps,
     cpp_args : [boost_args, test_arg],
diff --git a/attn/pel/pel_common.hpp b/attn/pel/pel_common.hpp
new file mode 100644
index 0000000..d0f3e15
--- /dev/null
+++ b/attn/pel/pel_common.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cstddef> // for size_t
+
+namespace attn
+{
+namespace pel
+{
+
+enum class SectionID
+{
+    privateHeader = 0x5048, // 'PH'
+    userHeader    = 0x5548, // 'UH'
+    primarySRC    = 0x5053, // 'PS'
+};
+
+enum class ComponentID
+{
+    attentionHandler = 0xd100
+};
+
+enum class CreatorID
+{
+    hostboot   = 'B',
+    hypervisor = 'H',
+    openbmc    = 'O'
+};
+
+enum class SubsystemID
+{
+    hypervisor = 0x82,
+    hostboot   = 0x8a,
+    openbmc    = 0x8d
+};
+
+enum class Severity
+{
+    information = 0x00,
+    termination = 0x51
+};
+
+enum class EventType
+{
+    na    = 0x00,
+    trace = 0x02
+};
+
+enum class ActionFlags
+{
+    service = 0x8000,
+    report  = 0x2000,
+    call    = 0x0800
+};
+
+inline ActionFlags operator|(ActionFlags a, ActionFlags b)
+{
+    return static_cast<ActionFlags>(static_cast<int>(a) | static_cast<int>(b));
+}
+
+enum class EventScope
+{
+    platform = 0x03
+};
+
+constexpr size_t numSrcWords = 8;  // number of SRC hex words
+const size_t asciiStringSize = 32; // size of SRC ascii string
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/pel_minimal.cpp b/attn/pel/pel_minimal.cpp
new file mode 100644
index 0000000..9d7dfc1
--- /dev/null
+++ b/attn/pel/pel_minimal.cpp
@@ -0,0 +1,95 @@
+#include "pel_minimal.hpp"
+
+#include "stream.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+PelMinimal::PelMinimal(std::vector<uint8_t>& data)
+{
+    Stream pelData{data};
+
+    _ph = std::make_unique<PrivateHeader>(pelData);
+    _uh = std::make_unique<UserHeader>(pelData);
+    _ps = std::make_unique<PrimarySrc>(pelData);
+}
+
+void PelMinimal::raw(std::vector<uint8_t>& pelBuffer) const
+{
+    Stream pelData{pelBuffer};
+
+    // stream from object to buffer
+    _ph->flatten(pelData);
+    _uh->flatten(pelData);
+    _ps->flatten(pelData);
+}
+
+size_t PelMinimal::size() const
+{
+    size_t size = 0;
+
+    // size of private header section
+    if (_ph)
+    {
+        size += _ph->header().size;
+    }
+
+    // size of user header section
+    if (_uh)
+    {
+        size += _uh->header().size;
+    }
+
+    // size of primary SRC section
+    if (_ps)
+    {
+        size += _ph->header().size;
+    }
+
+    return ((size > _maxPELSize) ? _maxPELSize : size);
+}
+
+void PelMinimal::setSubsystem(uint8_t subsystem)
+{
+    _uh->setSubsystem(subsystem);
+}
+
+void PelMinimal::setSeverity(uint8_t severity)
+{
+    _uh->setSeverity(severity);
+}
+
+void PelMinimal::setType(uint8_t type)
+{
+    _uh->setType(type);
+}
+
+void PelMinimal::setAction(uint16_t action)
+{
+    _uh->setAction(action);
+}
+
+void PelMinimal::setSrcWords(std::array<uint32_t, numSrcWords> srcWords)
+{
+    _ps->setSrcWords(srcWords);
+}
+
+void PelMinimal::setAsciiString(std::array<char, asciiStringSize> asciiString)
+{
+    _ps->setAsciiString(asciiString);
+}
+
+uint8_t PelMinimal::getSectionCount()
+{
+    return _ph->getSectionCount();
+}
+
+void PelMinimal::setSectionCount(uint8_t sectionCount)
+{
+    _ph->setSectionCount(sectionCount);
+}
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/pel_minimal.hpp b/attn/pel/pel_minimal.hpp
new file mode 100644
index 0000000..cde0ead
--- /dev/null
+++ b/attn/pel/pel_minimal.hpp
@@ -0,0 +1,144 @@
+#pragma once
+
+#include "pel_common.hpp"
+#include "primary_src.hpp"
+#include "private_header.hpp"
+#include "user_header.hpp"
+
+#include <vector>
+
+namespace attn
+{
+namespace pel
+{
+
+/** @class PelMinimal
+ *
+ * @brief Class for a minimal platform event log (PEL)
+ *
+ * This class can be used to create form a PEL and create a raw PEL file. The
+ * implementation based on "Platform Event Log and SRC PLDD v1.1"
+ *
+ * This PEL consists of the following position dependent sections:
+ *
+ * |----------+------------------------------|
+ * | length   | section                      |
+ * |----------+------------------------------|
+ * | 48       | Private Header Section       |
+ * |----------+------------------------------|
+ * | 24       | User Header Section          |
+ * |----------+------------------------------|
+ * | 72       | Primary SRC Section          |
+ * |----------+------------------------------|
+ */
+class PelMinimal
+{
+  public:
+    PelMinimal()                  = delete;
+    ~PelMinimal()                 = default;
+    PelMinimal(const PelMinimal&) = delete;
+    PelMinimal& operator=(const PelMinimal&) = delete;
+    PelMinimal(PelMinimal&&)                 = delete;
+    PelMinimal& operator=(PelMinimal&&) = delete;
+
+    /**
+     * @brief Create a minimal PEL object from raw data
+     *
+     * @param[in] pelBuffer - buffer containing a raw PEL
+     */
+    PelMinimal(std::vector<uint8_t>& data);
+
+    /**
+     * @brief Stream raw PEL data to buffer
+     *
+     * @param[out] pelBuffer - What the data will be written to
+     */
+    void raw(std::vector<uint8_t>& pelBuffer) const;
+
+    /**
+     * @brief Set the User Header subsystem field
+     *
+     * @param[in] subsystem - The subsystem value
+     */
+    void setSubsystem(uint8_t subsystem);
+
+    /**
+     * @brief Set the User Header severity field
+     *
+     * @param[in] severity - The severity to set
+     */
+    void setSeverity(uint8_t severity);
+
+    /**
+     * @brief Set the User Header event type field
+     *
+     * @param[in] type - The event type
+     */
+    void setType(uint8_t type);
+
+    /**
+     * @brief Set the User Header action flags field
+     *
+     * @param[in] action - The action flags to set
+     */
+    void setAction(uint16_t action);
+
+    /**
+     * @brief Set the Primary SRC section SRC words
+     *
+     * @param[in] srcWords - The SRC words
+     */
+    void setSrcWords(std::array<uint32_t, numSrcWords> srcWords);
+
+    /**
+     * @brief Set the Primary SRC section ascii string field
+     *
+     * @param[in]  asciiString - The ascii string
+     */
+    void setAsciiString(std::array<char, asciiStringSize> asciiString);
+
+    /**
+     * @brief Get section count from the private header
+     *
+     * @return Number of sections
+     */
+    uint8_t getSectionCount();
+
+    /**
+     * @brief Set section count in private heasder
+     *
+     * @param[in] sectionCount - Number of sections
+     */
+    void setSectionCount(uint8_t sectionCount);
+
+  private:
+    /**
+     * @brief Maximum PEL size
+     */
+    static constexpr size_t _maxPELSize = 16384;
+
+    /**
+     * @brief Returns the size of the PEL
+     *
+     * @return size_t The PEL size in bytes
+     */
+    size_t size() const;
+
+    /**
+     * @brief PEL Private Header
+     */
+    std::unique_ptr<PrivateHeader> _ph;
+
+    /**
+     * @brief PEL User Header
+     */
+    std::unique_ptr<UserHeader> _uh;
+
+    /**
+     * @brief PEL Primary SRC
+     */
+    std::unique_ptr<PrimarySrc> _ps;
+};
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/pel_section.hpp b/attn/pel/pel_section.hpp
new file mode 100644
index 0000000..ca8dce4
--- /dev/null
+++ b/attn/pel/pel_section.hpp
@@ -0,0 +1,59 @@
+#pragma once
+
+#include "section_header.hpp"
+
+namespace attn
+{
+namespace pel
+{
+/**
+ * @class Section
+ *
+ * The base class for a PEL section.  It contains the SectionHeader
+ * as all sections start with it.
+ *
+ */
+class Section
+{
+  public:
+    Section()               = default;
+    virtual ~Section()      = default;
+    Section(const Section&) = default;
+    Section& operator=(const Section&) = default;
+    Section(Section&&)                 = default;
+    Section& operator=(Section&&) = default;
+
+    /**
+     * @brief Returns a reference to the SectionHeader
+     */
+    const SectionHeader& header() const
+    {
+        return _header;
+    }
+
+    /**
+     * @brief Flatten the section into the stream
+     *
+     * @param[in] stream - The stream to write to
+     */
+    virtual void flatten(Stream& stream) const = 0;
+
+  protected:
+    /**
+     * @brief Returns the flattened size of the section header
+     */
+    static constexpr size_t flattenedSize()
+    {
+        return SectionHeader::flattenedSize();
+    }
+
+    /**
+     * @brief The section header structure.
+     *
+     * Filled in by derived classes.
+     */
+    SectionHeader _header;
+};
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/primary_src.cpp b/attn/pel/primary_src.cpp
new file mode 100644
index 0000000..0123395
--- /dev/null
+++ b/attn/pel/primary_src.cpp
@@ -0,0 +1,50 @@
+#include "primary_src.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+PrimarySrc::PrimarySrc(Stream& pel)
+{
+    unflatten(pel);
+}
+
+void PrimarySrc::flatten(Stream& stream) const
+{
+    stream << _header << _version << _flags << _reserved1B << _wordCount
+           << _reserved2B << _size;
+
+    for (auto& word : _srcWords)
+    {
+        stream << word;
+    }
+
+    stream.write(_asciiString.data(), _asciiString.size());
+}
+
+void PrimarySrc::unflatten(Stream& stream)
+{
+    stream >> _header >> _version >> _flags >> _reserved1B >> _wordCount >>
+        _reserved2B >> _size;
+
+    for (auto& word : _srcWords)
+    {
+        stream >> word;
+    }
+
+    stream.read(_asciiString.data(), _asciiString.size());
+}
+
+void PrimarySrc::setSrcWords(std::array<uint32_t, numSrcWords> srcWords)
+{
+    _srcWords = srcWords;
+}
+
+void PrimarySrc::setAsciiString(std::array<char, asciiStringSize> asciiString)
+{
+    _asciiString = asciiString;
+}
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/primary_src.hpp b/attn/pel/primary_src.hpp
new file mode 100644
index 0000000..659cb48
--- /dev/null
+++ b/attn/pel/primary_src.hpp
@@ -0,0 +1,150 @@
+#pragma once
+
+#include "pel_common.hpp"
+#include "pel_section.hpp"
+#include "stream.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+/**
+ * @class PrimarySrc
+ *
+ * @brief This class represents the primary SRC sections in the PEL.
+ *
+ * |--------+--------------------------------------------|
+ * | length | field                                      |
+ * |--------+--------------------------------------------|
+ * | 1      | Version = 0x02                             |
+ * |--------+--------------------------------------------|
+ * | 1      | Flags = 0x00 (no additional data sections) |
+ * |--------+--------------------------------------------|
+ * | 1      | reserved                                   |
+ * |--------+--------------------------------------------|
+ * | 1      | Number of words of hex data + 1 = 0x09     |
+ * |--------+--------------------------------------------|
+ * | 2      | reserved                                   |
+ * |--------+--------------------------------------------|
+ * | 2      | Total length of SRC in bytes = 0x48        |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 2 (word 1 intentionally skipped)  |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 3                                 |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 4                                 |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 5                                 |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 6                                 |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 7                                 |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 8                                 |
+ * |--------+--------------------------------------------|
+ * | 4      | Hex Word 9                                 |
+ * |--------+--------------------------------------------|
+ * | 32     | ASCII String                               |
+ * |--------+--------------------------------------------|
+ */
+class PrimarySrc : public Section
+{
+  public:
+    enum HeaderFlags
+    {
+        additionalSections  = 0x01,
+        powerFaultEvent     = 0x02,
+        hypDumpInit         = 0x04,
+        i5OSServiceEventBit = 0x10,
+        virtualProgressSRC  = 0x80
+    };
+
+    PrimarySrc()                  = delete;
+    ~PrimarySrc()                 = default;
+    PrimarySrc(const PrimarySrc&) = delete;
+    PrimarySrc& operator=(const PrimarySrc&) = delete;
+    PrimarySrc(PrimarySrc&&)                 = delete;
+    PrimarySrc& operator=(PrimarySrc&&) = delete;
+
+    /**
+     * @brief Constructor
+     *
+     * Fills in this class's data fields from raw data.
+     *
+     * @param[in] pel - the PEL data stream
+     */
+    explicit PrimarySrc(Stream& pel);
+
+    /**
+     * @brief Flatten the section into the stream
+     *
+     * @param[in] stream - The stream to write to
+     */
+    void flatten(Stream& stream) const override;
+
+    /**
+     * @brief Fills in the object from the stream data
+     *
+     * @param[in] stream - The stream to read from
+     */
+    void unflatten(Stream& stream);
+
+    /**
+     * @brief Set the SRC words
+     *
+     * @param[in] srcWords - The SRC words
+     */
+    void setSrcWords(std::array<uint32_t, numSrcWords> srcWords);
+
+    /**
+     * @brief Set the ascii string field
+     *
+     * @param[in]  asciiString - The ascii string
+     */
+    void setAsciiString(std::array<char, asciiStringSize> asciiString);
+
+  private:
+    /**
+     * @brief The SRC version field
+     */
+    uint8_t _version = 0x02;
+
+    /**
+     * @brief The SRC flags field
+     */
+    uint8_t _flags = 0;
+
+    /**
+     * @brief A byte of reserved data after the flags field
+     */
+    uint8_t _reserved1B = 0;
+
+    /**
+     * @brief The hex data word count.
+     */
+    uint8_t _wordCount = numSrcWords + 1; // +1 for backward compatability
+
+    /**
+     * @brief Two bytes of reserved data after the hex word count
+     */
+    uint16_t _reserved2B = 0;
+
+    /**
+     * @brief The total size of the SRC section (w/o section header)
+     */
+    uint16_t _size = 72; // 72 (bytes) = size of basic SRC section
+
+    /**
+     * @brief The SRC 'hex words'.
+     */
+    std::array<uint32_t, numSrcWords> _srcWords;
+
+    /**
+     * @brief The 32 byte ASCII character string of the SRC
+     */
+    std::array<char, asciiStringSize> _asciiString;
+};
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/private_header.cpp b/attn/pel/private_header.cpp
new file mode 100644
index 0000000..18d06d4
--- /dev/null
+++ b/attn/pel/private_header.cpp
@@ -0,0 +1,58 @@
+#include "private_header.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+PrivateHeader::PrivateHeader(Stream& pel)
+{
+    unflatten(pel);
+}
+
+void PrivateHeader::flatten(Stream& stream) const
+{
+    stream << _header << _createTimestamp << _commitTimestamp << _creatorID
+           << _reservedByte1 << _reservedByte2 << _sectionCount << _obmcLogID
+           << _creatorVersion << _plid << _id;
+}
+
+void PrivateHeader::unflatten(Stream& stream)
+{
+    stream >> _header >> _createTimestamp >> _commitTimestamp >> _creatorID >>
+        _reservedByte1 >> _reservedByte2 >> _sectionCount >> _obmcLogID >>
+        _creatorVersion >> _plid >> _id;
+}
+
+uint8_t PrivateHeader::getSectionCount()
+{
+    return _sectionCount;
+}
+
+void PrivateHeader::setSectionCount(uint8_t sectionCount)
+{
+    _sectionCount = sectionCount;
+}
+
+/*
+Stream& operator<<(Stream& s, const CreatorVersion& cv)
+{
+    for (size_t i = 0; i < sizeof(CreatorVersion); i++)
+    {
+        s << cv.version[i];
+    }
+    return s;
+}
+
+Stream& operator>>(Stream& s, CreatorVersion& cv)
+{
+    for (size_t i = 0; i < sizeof(CreatorVersion); i++)
+    {
+        s >> cv.version[i];
+    }
+    return s;
+}
+*/
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/private_header.hpp b/attn/pel/private_header.hpp
new file mode 100644
index 0000000..3b80968
--- /dev/null
+++ b/attn/pel/private_header.hpp
@@ -0,0 +1,191 @@
+#pragma once
+
+//#include "bcd_time.hpp"
+#include "pel_common.hpp"
+#include "pel_section.hpp"
+#include "stream.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+// creator version field type, init to null terminated
+// struct CreatorVersion
+//{
+//    uint8_t version[8];
+
+//    CreatorVersion()
+//    {
+//        memset(version, '\0', sizeof(version));
+//    }
+//};
+
+/**
+ * @class PrivateHeader
+ *
+ * This represents the Private Header section in a PEL.  It is required,
+ * and it is always the first section.
+ *
+ * The Section base class handles the SectionHeader structure that every
+ * PEL section has at offset zero.
+ *
+ * |--------+----------------------+----------+----------+---------------|
+ * | length | byte0                | byte1    | byte2    | byte3         |
+ * |--------+----------------------+----------+----------+---------------|
+ * | 8      | Section Header                                             |
+ * |        |                                                            |
+ * |--------+------------------------------------------------------------|
+ * | 8      | Timestamp - Creation                                       |
+ * |        |                                                            |
+ * |--------+------------------------------------------------------------|
+ * | 8      | Timestamp - Commit                                         |
+ * |        |                                                            |
+ * |--------+----------------------+----------+----------+---------------|
+ * | 4      | Creator ID           | reserved | reserved | section count |
+ * |--------+----------------------+----------+----------+---------------|
+ * | 4      | OpenBMC Event Log ID                                       |
+ * |--------+------------------------------------------------------------|
+ * | 8      | Creator Implementation                                     |
+ * |        |                                                            |
+ * |--------+------------------------------------------------------------|
+ * | 4      | Platform Log ID                                            |
+ * |--------+------------------------------------------------------------|
+ * | 4      | Log Entry ID                                               |
+ * |--------+------------------------------------------------------------|
+ */
+class PrivateHeader : public Section
+{
+  public:
+    PrivateHeader()                     = delete;
+    ~PrivateHeader()                    = default;
+    PrivateHeader(const PrivateHeader&) = default;
+    PrivateHeader& operator=(const PrivateHeader&) = default;
+    PrivateHeader(PrivateHeader&&)                 = default;
+    PrivateHeader& operator=(PrivateHeader&&) = default;
+
+    /**
+     * @brief Constructor
+     *
+     * Fills in this class's data fields from raw data.
+     *
+     * @param[in] pel - the PEL data stream
+     *
+     */
+    explicit PrivateHeader(Stream& pel);
+
+    /**
+     * @brief Flatten the section into the stream
+     *
+     * @param[in] stream - The stream to write to
+     */
+    void flatten(Stream& stream) const override;
+
+    /**
+     * @brief Fills in the object from the stream data
+     *
+     * @param[in] stream - The stream to read from
+     */
+    void unflatten(Stream& stream);
+
+    /**
+     * @brief Returns the size of this section when flattened into a PEL
+     *
+     * @return size_t - the size of the section
+     */
+    static constexpr size_t flattenedSize()
+    {
+        return Section::flattenedSize() + sizeof(_createTimestamp) +
+               sizeof(_commitTimestamp) + sizeof(_creatorID) +
+               sizeof(_reservedByte1) + sizeof(_reservedByte2) +
+               sizeof(_sectionCount) + sizeof(_obmcLogID) +
+               sizeof(_creatorVersion) + sizeof(_plid) + sizeof(_id);
+    }
+
+    /**
+     * @brief Get the total number of sections in this PEL
+     *
+     * @return Number of sections
+     */
+    uint8_t getSectionCount();
+
+    /**
+     * @brief Set the total number of sections in this PEL
+     *
+     * @param[in] sectionCount - Number of sections
+     */
+    void setSectionCount(uint8_t sectionCount);
+
+  private:
+    /**
+     * @brief The creation time timestamp
+     */
+    uint64_t _createTimestamp;
+    // BCDTime _createTimestamp;
+
+    /**
+     * @brief The commit time timestamp
+     */
+    uint64_t _commitTimestamp;
+    // BCDTime _commitTimestamp;
+
+    /**
+     * @brief The creator ID field
+     */
+    uint8_t _creatorID;
+
+    /**
+     * @brief A reserved byte.
+     */
+    uint8_t _reservedByte1 = 0;
+
+    /**
+     * @brief A reserved byte.
+     */
+    uint8_t _reservedByte2 = 0;
+
+    /**
+     * @brief Total number of sections in the PEL
+     */
+    uint8_t _sectionCount = 3; // private header, user header, primary src = 3
+
+    /**
+     * @brief The OpenBMC event log ID that corresponds to this PEL.
+     */
+    uint32_t _obmcLogID = 0;
+
+    /**
+     * @brief The creator subsystem version field
+     */
+    uint64_t _creatorVersion;
+    // CreatorVersion _creatorVersion;
+
+    /**
+     * @brief The platform log ID field
+     */
+    uint32_t _plid;
+
+    /**
+     * @brief The log entry ID field
+     */
+    uint32_t _id = 0;
+};
+
+/**
+ * @brief Stream insertion operator for the CreatorVersion
+ *
+ * @param[out] s - the stream
+ * @param[in] cv - the CreatorVersion object
+ */
+// Stream& operator<<(Stream& s, const CreatorVersion& cv);
+
+/**
+ * @brief Stream extraction operator for the CreatorVersion
+ *
+ * @param[in] s - the stream
+ * @param[out] cv - the CreatorVersion object
+ */
+// Stream& operator>>(Stream& s, CreatorVersion& cv);
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/section_header.hpp b/attn/pel/section_header.hpp
new file mode 100644
index 0000000..ae0a2c5
--- /dev/null
+++ b/attn/pel/section_header.hpp
@@ -0,0 +1,130 @@
+#pragma once
+
+#include "stream.hpp"
+
+#include <cstdint>
+
+namespace attn
+{
+namespace pel
+{
+
+/**
+ * @class SectionHeader
+ *
+ * @brief This 8-byte header is at the start of every PEL section.
+ *
+ * |--------+------------+------------+-----------+------------|
+ * | length | byte0      | byte1      | byte2     | byte3      |
+ * |--------+------------+------------+-----------+------------|
+ * | 4      | Section ID              | Section Length         |
+ * |--------+------------+-------------------------------------|
+ * | 4      | Version    | Sub-type   | Component ID           |
+ * |--------+--------------------------------------------------|
+ *
+ * Section ID:
+ * A two-ASCII character field which uniquely identifies the type of section.
+ *
+ * Section length:
+ * Length in bytes of the section, including the entire section header.
+ *
+ * Section Version:
+ * A one byte integer intended to identify differences in header structures.
+ *
+ * Section sub-type:
+ * Optional. Additional identifier describing the section.
+ *
+ * Component IDs:
+ * Optional. By convention the creator's component ID is placed in the
+ * component ID field of the Private Header and the committing component
+ * ID is placed in the component ID field of the User Header.
+ */
+struct SectionHeader
+{
+  public:
+    /**
+     * @brief Constructor
+     */
+    SectionHeader() : id(0), size(0), version(0), subType(0), componentID(0) {}
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] id - the ID field
+     * @param[in] size - the size field
+     * @param[in] version - the version field
+     * @param[in] subType - the sub-type field
+     * @param[in] componentID - the component ID field
+     */
+    SectionHeader(uint16_t id, uint16_t size, uint8_t version, uint8_t subType,
+                  uint16_t componentID) :
+        id(id),
+        size(size), version(version), subType(subType), componentID(componentID)
+    {}
+
+    /**
+     * @brief A two character ASCII field which identifies the section type.
+     */
+    uint16_t id;
+
+    /**
+     * @brief The size of the section in bytes, including this section header.
+     */
+    uint16_t size;
+
+    /**
+     * @brief The section format version.
+     */
+    uint8_t version;
+
+    /**
+     * @brief The section sub-type.
+     */
+    uint8_t subType;
+
+    /**
+     * @brief The component ID, which has various meanings depending on the
+     * section.
+     */
+    uint16_t componentID;
+
+    /**
+     * @brief Returns the size of header when flattened into a PEL.
+     *
+     * @return size_t - the size of the header
+     */
+    static constexpr size_t flattenedSize()
+    {
+        return sizeof(id) + sizeof(size) + sizeof(version) + sizeof(subType) +
+               sizeof(componentID);
+    }
+};
+
+/**
+ * @brief Stream extraction operator for the SectionHeader
+ *
+ * @param[in] s - the stream
+ * @param[out] header - the SectionHeader object
+ */
+inline Stream& operator>>(Stream& s, SectionHeader& header)
+{
+    s >> header.id >> header.size >> header.version >> header.subType >>
+        header.componentID;
+    return s;
+}
+
+/**
+ * @brief Stream insertion operator for the section header
+ *
+ * @param[out] s - the stream
+ * @param[in] header - the SectionHeader object
+ */
+inline Stream& operator<<(Stream& s, const SectionHeader& header)
+{
+    s << header.id << header.size << header.version << header.subType
+      << header.componentID;
+    return s;
+}
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/stream.hpp b/attn/pel/stream.hpp
new file mode 100644
index 0000000..a82bd8a
--- /dev/null
+++ b/attn/pel/stream.hpp
@@ -0,0 +1,372 @@
+#pragma once
+
+#include <arpa/inet.h>
+#include <byteswap.h>
+
+#include <cassert>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace attn
+{
+namespace pel
+{
+
+namespace detail
+{
+/**
+ * @brief A host-to-network implementation for uint64_t
+ *
+ * @param[in] value - the value to convert to
+ * @return uint64_t - the byteswapped value
+ */
+inline uint64_t htonll(uint64_t value)
+{
+    return bswap_64(value);
+}
+
+/**
+ * @brief A network-to-host implementation for uint64_t
+ *
+ * @param[in] value - the value to convert to
+ * @return uint64_t - the byteswapped value
+ */
+inline uint64_t ntohll(uint64_t value)
+{
+    return bswap_64(value);
+}
+} // namespace detail
+
+/**
+ * @class Stream
+ *
+ * This class is used for getting data types into and out of a vector<uint8_t>
+ * that contains data in network byte (big endian) ordering.
+ */
+class Stream
+{
+  public:
+    Stream()              = delete;
+    ~Stream()             = default;
+    Stream(const Stream&) = default;
+    Stream& operator=(const Stream&) = default;
+    Stream(Stream&&)                 = default;
+    Stream& operator=(Stream&&) = default;
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] data - the vector of data
+     */
+    explicit Stream(std::vector<uint8_t>& data) : _data(data), _offset(0) {}
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] data - the vector of data
+     * @param[in] offset - the starting offset
+     */
+    Stream(std::vector<uint8_t>& data, std::size_t offset) :
+        _data(data), _offset(offset)
+    {
+        if (_offset >= _data.size())
+        {
+            throw std::out_of_range("Offset out of range");
+        }
+    }
+
+    /**
+     * @brief Extraction operator for a uint8_t
+     *
+     * @param[out] value - filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(uint8_t& value)
+    {
+        read(&value, 1);
+        return *this;
+    }
+
+    /**
+     * @brief Extraction operator for a char
+     *
+     * @param[out] value -filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(char& value)
+    {
+        read(&value, 1);
+        return *this;
+    }
+
+    /**
+     * @brief Extraction operator for a uint16_t
+     *
+     * @param[out] value -filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(uint16_t& value)
+    {
+        read(&value, 2);
+        value = htons(value);
+        return *this;
+    }
+
+    /**
+     * @brief Extraction operator for a uint32_t
+     *
+     * @param[out] value -filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(uint32_t& value)
+    {
+        read(&value, 4);
+        value = htonl(value);
+        return *this;
+    }
+
+    /**
+     * @brief Extraction operator for a uint64_t
+     *
+     * @param[out] value -filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(uint64_t& value)
+    {
+        read(&value, 8);
+        value = detail::htonll(value);
+        return *this;
+    }
+
+    /**
+     * @brief Extraction operator for a std::vector<uint8_t>
+     *
+     * The vector's size is the amount extracted.
+     *
+     * @param[out] value - filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(std::vector<uint8_t>& value)
+    {
+        if (!value.empty())
+        {
+            read(value.data(), value.size());
+        }
+        return *this;
+    }
+
+    /**
+     * @brief Extraction operator for a std::vector<char>
+     *
+     * The vector's size is the amount extracted.
+     *
+     * @param[out] value - filled in with the value
+     * @return Stream&
+     */
+    Stream& operator>>(std::vector<char>& value)
+    {
+        if (!value.empty())
+        {
+            read(value.data(), value.size());
+        }
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a uint8_t
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(uint8_t value)
+    {
+        write(&value, 1);
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a char
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(char value)
+    {
+        write(&value, 1);
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a uint16_t
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(uint16_t value)
+    {
+        uint16_t data = ntohs(value);
+        write(&data, 2);
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a uint32_t
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(uint32_t value)
+    {
+        uint32_t data = ntohl(value);
+        write(&data, 4);
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a uint64_t
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(uint64_t value)
+    {
+        uint64_t data = detail::ntohll(value);
+        write(&data, 8);
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a std::vector<uint8_t>
+     *
+     * The full vector is written to the stream.
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(const std::vector<uint8_t>& value)
+    {
+        if (!value.empty())
+        {
+            write(value.data(), value.size());
+        }
+        return *this;
+    }
+
+    /**
+     * @brief Insert operator for a std::vector<char>
+     *
+     * The full vector is written to the stream.
+     *
+     * @param[in] value - the value to write to the stream
+     * @return Stream&
+     */
+    Stream& operator<<(const std::vector<char>& value)
+    {
+        if (!value.empty())
+        {
+            write(value.data(), value.size());
+        }
+        return *this;
+    }
+
+    /**
+     * @brief Sets the offset of the stream
+     *
+     * @param[in] newOffset - the new offset
+     */
+    void offset(std::size_t newOffset)
+    {
+        if (newOffset >= _data.size())
+        {
+            throw std::out_of_range("new offset out of range");
+        }
+
+        _offset = newOffset;
+    }
+
+    /**
+     * @brief Returns the current offset of the stream
+     *
+     * @return size_t - the offset
+     */
+    std::size_t offset() const
+    {
+        return _offset;
+    }
+
+    /**
+     * @brief Returns the remaining bytes left between the current offset
+     *        and the data size.
+     *
+     * @return size_t - the remaining size
+     */
+    std::size_t remaining() const
+    {
+        assert(_data.size() >= _offset);
+        return _data.size() - _offset;
+    }
+
+    /**
+     * @brief Reads a specified number of bytes out of a stream
+     *
+     * @param[out] out - filled in with the data
+     * @param[in] size - the size to read
+     */
+    void read(void* out, std::size_t size)
+    {
+        rangeCheck(size);
+        memcpy(out, &_data[_offset], size);
+        _offset += size;
+    }
+
+    /**
+     * @brief Writes a specified number of bytes into the stream
+     *
+     * @param[in] in - the data to write
+     * @param[in] size - the size to write
+     */
+    void write(const void* in, std::size_t size)
+    {
+        size_t newSize = _offset + size;
+        if (newSize > _data.size())
+        {
+            _data.resize(newSize, 0);
+        }
+        memcpy(&_data[_offset], in, size);
+        _offset += size;
+    }
+
+  private:
+    /**
+     * @brief Throws an exception if the size passed in plus the current
+     *        offset is bigger than the current data size.
+     * @param[in] size - the size to check
+     */
+    void rangeCheck(std::size_t size)
+    {
+        if (_offset + size > _data.size())
+        {
+            std::string msg{"Attempted stream overflow: offset "};
+            msg += std::to_string(_offset) + " buffer size " +
+                   std::to_string(_data.size()) + " op size " +
+                   std::to_string(size);
+            throw std::out_of_range(msg.c_str());
+        }
+    }
+
+    /**
+     * @brief The data that the stream accesses.
+     */
+    std::vector<uint8_t>& _data;
+
+    /**
+     * @brief The current offset of the stream.
+     */
+    std::size_t _offset;
+};
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/user_header.cpp b/attn/pel/user_header.cpp
new file mode 100644
index 0000000..23238e8
--- /dev/null
+++ b/attn/pel/user_header.cpp
@@ -0,0 +1,48 @@
+#include "user_header.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+UserHeader::UserHeader(Stream& pel)
+{
+    unflatten(pel);
+}
+
+void UserHeader::flatten(Stream& stream) const
+{
+    stream << _header << _eventSubsystem << _eventScope << _eventSeverity
+           << _eventType << _reserved4Byte1 << _problemDomain << _problemVector
+           << _actionFlags << _reserved4Byte2;
+}
+
+void UserHeader::unflatten(Stream& stream)
+{
+    stream >> _header >> _eventSubsystem >> _eventScope >> _eventSeverity >>
+        _eventType >> _reserved4Byte1 >> _problemDomain >> _problemVector >>
+        _actionFlags >> _reserved4Byte2;
+}
+
+void UserHeader::setSubsystem(uint8_t subsystem)
+{
+    _eventSubsystem = subsystem;
+}
+
+void UserHeader::setSeverity(uint8_t severity)
+{
+    _eventSeverity = severity;
+}
+
+void UserHeader::setType(uint8_t type)
+{
+    _eventType = type;
+}
+
+void UserHeader::setAction(uint16_t action)
+{
+    _actionFlags = action;
+}
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/pel/user_header.hpp b/attn/pel/user_header.hpp
new file mode 100644
index 0000000..3be6e66
--- /dev/null
+++ b/attn/pel/user_header.hpp
@@ -0,0 +1,157 @@
+#pragma once
+
+#include "pel_common.hpp"
+#include "pel_section.hpp"
+#include "stream.hpp"
+
+namespace attn
+{
+namespace pel
+{
+
+/**
+ * @class UserHeader
+ *
+ * This represents the User Header section in a PEL.
+ *
+ * |--------+----------------+----------------+----------------+------------|
+ * | length | byte0          | byte1          | byte2          | byte3      |
+ * |--------+----------------+----------------+----------------+------------|
+ * | 8      | Section Header                                                |
+ * |        |                                                               |
+ * |--------+----------------+----------------+----------------+------------|
+ * | 4      | Subsystem ID   | Event Scope    | Event Severity | Event Type |
+ * |--------+----------------+----------------+----------------+------------|
+ * | 4      | reserved                                                      |
+ * |--------+----------------+----------------+-----------------------------|
+ * | 4      | Problem Domain | Problem Vector | Event Action Flags          |
+ * |--------+----------------+----------------+-----------------------------|
+ * | 4      | reserved                                                      |
+ * |--------+---------------------------------------------------------------|
+ *
+ */
+class UserHeader : public Section
+{
+  public:
+    UserHeader()                  = delete;
+    ~UserHeader()                 = default;
+    UserHeader(const UserHeader&) = default;
+    UserHeader& operator=(const UserHeader&) = default;
+    UserHeader(UserHeader&&)                 = default;
+    UserHeader& operator=(UserHeader&&) = default;
+
+    /**
+     * @brief Constructor
+     *
+     * Fills in this class's data fields from raw data.
+     *
+     * @param[in] pel - the PEL data stream
+     */
+    explicit UserHeader(Stream& pel);
+
+    /**
+     * @brief Flatten the section into the stream
+     *
+     * @param[in] stream - The stream to write to
+     */
+    void flatten(Stream& stream) const override;
+
+    /**
+     * @brief Fills in the object from the stream data
+     *
+     * @param[in] stream - The stream to read from
+     */
+    void unflatten(Stream& stream);
+
+    /**
+     * @brief Returns the size of this section when flattened into a PEL
+     *
+     * @return size_t - the size of the section
+     */
+    static constexpr size_t flattenedSize()
+    {
+        return Section::flattenedSize() + sizeof(_eventSubsystem) +
+               sizeof(_eventScope) + sizeof(_eventSeverity) +
+               sizeof(_eventType) + sizeof(_reserved4Byte1) +
+               sizeof(_problemDomain) + sizeof(_problemVector) +
+               sizeof(_actionFlags) + sizeof(_reserved4Byte2);
+    }
+
+    /**
+     * @brief Set the subsystem field
+     *
+     * @param[in] subsystem - The subsystem value
+     */
+    void setSubsystem(uint8_t subsystem);
+
+    /**
+     * @brief Set the severity field
+     *
+     * @param[in] severity - The severity to set
+     */
+    void setSeverity(uint8_t severity);
+
+    /**
+     * @brief Set the event type field
+     *
+     * @param[in] type - The event type
+     */
+    void setType(uint8_t type);
+
+    /**
+     * @brief Set the action flags field
+     *
+     * @param[in] action - The action flags to set
+     */
+    void setAction(uint16_t action);
+
+  private:
+    /**
+     * @brief The subsystem associated with the event.
+     */
+    uint8_t _eventSubsystem;
+
+    /**
+     * @brief The event scope field.
+     */
+    uint8_t _eventScope = static_cast<uint8_t>(EventScope::platform);
+
+    /**
+     * @brief The event severity.
+     */
+    uint8_t _eventSeverity; // set by constructor
+
+    /**
+     * @brief The event type.
+     */
+    uint8_t _eventType = static_cast<uint8_t>(EventType::trace);
+
+    /**
+     * @brief A reserved 4 byte placeholder
+     */
+    uint32_t _reserved4Byte1 = 0;
+
+    /**
+     * @brief The problem domain field.
+     */
+    uint8_t _problemDomain = 0;
+
+    /**
+     * @brief The problem vector field.
+     */
+    uint8_t _problemVector = 0;
+
+    /**
+     * @brief The action flags field.
+     */
+    uint16_t _actionFlags; // set by contructor
+
+    /**
+     * @brief A reserved 4 byte
+     * placeholder
+     */
+    uint32_t _reserved4Byte2 = 0;
+};
+
+} // namespace pel
+} // namespace attn
diff --git a/attn/ti_handler.cpp b/attn/ti_handler.cpp
index 35fb346..e1dce7c 100644
--- a/attn/ti_handler.cpp
+++ b/attn/ti_handler.cpp
@@ -1,6 +1,7 @@
 #include <attn/attn_common.hpp>
 #include <attn/attn_handler.hpp>
 #include <attn/attn_logging.hpp>
+#include <attn/pel/pel_common.hpp>
 #include <attn/ti_handler.hpp>
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/exception.hpp>
@@ -17,7 +18,7 @@
  * Use the TI info data area to determine if this is either a HB or a PHYP
  * TI event then handle the event.
  *
- * @param i_tiDataArea pointer to the TI infor data
+ * @param i_tiDataArea pointer to the TI info data
  */
 int tiHandler(TiDataArea* i_tiDataArea)
 {
@@ -84,10 +85,17 @@
     if (nullptr != i_tiDataArea)
     {
         parsePhypOpalTiInfo(tiAdditionalData, i_tiDataArea);
-        parseRawTiInfo(tiAdditionalData, i_tiDataArea);
     }
 
-    eventTerminate(tiAdditionalData); // generate PEL
+    tiAdditionalData["Subsystem"] =
+        std::to_string(static_cast<uint8_t>(pel::SubsystemID::hypervisor));
+
+    char srcChar[8];
+    memcpy(srcChar, &(i_tiDataArea->asciiData0), 4);
+    memcpy(&srcChar[4], &(i_tiDataArea->asciiData1), 4);
+    tiAdditionalData["SrcAscii"] = std::string{srcChar};
+
+    eventTerminate(tiAdditionalData, (char*)i_tiDataArea);
 }
 
 /**
@@ -207,42 +215,19 @@
     if (nullptr != i_tiDataArea)
     {
         parseHbTiInfo(tiAdditionalData, i_tiDataArea);
-        parseRawTiInfo(tiAdditionalData, i_tiDataArea);
     }
 
     if (true == generatePel)
     {
-        eventTerminate(tiAdditionalData); // generate PEL
-    }
-}
+        tiAdditionalData["Subsystem"] =
+            std::to_string(static_cast<uint8_t>(pel::SubsystemID::hostboot));
 
-/** @brief Parse the TI info data area into map as raw 32-bit fields */
-void parseRawTiInfo(std::map<std::string, std::string>& i_map,
-                    TiDataArea* i_buffer)
-{
-    if (nullptr == i_buffer)
-    {
-        return;
-    }
+        char srcChar[8];
+        memcpy(srcChar, &(i_tiDataArea->srcWord12HbWord0), 4);
+        memcpy(&srcChar[4], &(i_tiDataArea->asciiData1), 4);
+        tiAdditionalData["SrcAscii"] = std::string{srcChar};
 
-    uint32_t* tiDataArea = (uint32_t*)i_buffer;
-    std::stringstream ss;
-
-    ss << std::hex << std::setfill('0');
-    ss << "raw:";
-    while (tiDataArea <= (uint32_t*)((char*)i_buffer + sizeof(TiDataArea)))
-    {
-        ss << std::setw(8) << std::endl << be32toh(*tiDataArea);
-        tiDataArea++;
-    }
-
-    std::string key, value;
-    char delim = ':';
-
-    while (std::getline(ss, key, delim))
-    {
-        std::getline(ss, value, delim);
-        i_map[key] = value;
+        eventTerminate(tiAdditionalData, (char*)i_tiDataArea);
     }
 }
 
diff --git a/attn/ti_handler.hpp b/attn/ti_handler.hpp
index 33714a1..492868c 100644
--- a/attn/ti_handler.hpp
+++ b/attn/ti_handler.hpp
@@ -109,14 +109,6 @@
 void handleHbTi(TiDataArea* i_tiDataArea);
 
 /**
- * @brief Parse TI info data as raw 32-bit fields
- *
- * Read the TI data in as 32-bit fields and place into map.
- */
-void parseRawTiInfo(std::map<std::string, std::string>& i_map,
-                    TiDataArea* i_buffer);
-
-/**
  * @brief Parse TI info data as PHYP/OPAL data
  *
  * Read the TI data, parse as PHYP/OPAL data and place into map.
diff --git a/meson.build b/meson.build
index c2a74c7..64cf993 100644
--- a/meson.build
+++ b/meson.build
@@ -92,4 +92,3 @@
 if not build_tests.disabled()
   subdir('test')
 endif
-
diff --git a/test/end2end/logging.cpp b/test/end2end/logging.cpp
index 5163c4e..a03ad4c 100644
--- a/test/end2end/logging.cpp
+++ b/test/end2end/logging.cpp
@@ -31,7 +31,8 @@
     std::cout << "event: attention fail" << i_error << std::endl;
 }
 
-void eventTerminate(std::map<std::string, std::string> i_additionalData)
+void eventTerminate(std::map<std::string, std::string> i_additionalData,
+                    char* i_tiInfoData)
 {
     std::cout << "event: terminate" << std::endl;
 
@@ -41,6 +42,11 @@
         std::cout << '\t' << itr->first << '\t' << itr->second << '\n';
     }
     std::cout << std::endl;
+
+    if (nullptr != i_tiInfoData)
+    {
+        std::cout << "TI data present" << std::endl;
+    }
 }
 
 void eventVital()