diff --git a/Makefile.am b/Makefile.am
index 55d0818..1d4ddec 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,6 @@
 AM_DEFAULT_SOURCE_EXT = .cpp
 
-SUBDIRS = .
+SUBDIRS = . test
 
 if WANT_PRESENCE
 SUBDIRS += presence
diff --git a/configure.ac b/configure.ac
index 3d79076..89221ad 100644
--- a/configure.ac
+++ b/configure.ac
@@ -100,6 +100,12 @@
        AC_SUBST([PFPGEN],
                 ["$PYTHON \${top_srcdir}/presence/pfpgen.py generate-cpp -i $PRESENCE_CONFIG"])
     ])
+
+    AC_ARG_VAR(NUM_PRESENCE_LOG_ENTRIES, [Maximum number of entries in the message log])
+    AS_IF([test "x$NUM_PRESENCE_LOG_ENTRIES" == "x"], [NUM_PRESENCE_LOG_ENTRIES=50])
+    AC_DEFINE_UNQUOTED([NUM_PRESENCE_LOG_ENTRIES], [$NUM_PRESENCE_LOG_ENTRIES],
+                       [Maximum number of entries in the message log])
+
     AC_CONFIG_FILES([presence/Makefile])
 ])
 
@@ -191,5 +197,5 @@
 ])
 
 # Create configured output
-AC_CONFIG_FILES([Makefile presence/test/Makefile])
+AC_CONFIG_FILES([Makefile test/Makefile presence/test/Makefile])
 AC_OUTPUT
diff --git a/logger.hpp b/logger.hpp
new file mode 100644
index 0000000..f31ff36
--- /dev/null
+++ b/logger.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <unistd.h>
+
+#include <nlohmann/json.hpp>
+#include <phosphor-logging/log.hpp>
+
+#include <cassert>
+#include <ctime>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace phosphor::fan
+{
+
+/**
+ * @class Logger
+ *
+ * A simple logging class that stores log messages in a vector along
+ * with their timestamp.  When a messaged is logged, it will also be
+ * written to the journal.
+ *
+ * A saveToTempFile() function will write the log entries as JSON to
+ * a temporary file, so they can be added to event logs.
+ *
+ * The maximum number of entries to keep is specified in the
+ * constructor, and after that is hit the oldest entry will be
+ * removed when a new one is added.
+ */
+class Logger
+{
+  public:
+    // timestamp, message
+    using LogEntry = std::tuple<std::string, std::string>;
+
+    enum Priority
+    {
+        error,
+        info
+    };
+
+    Logger() = delete;
+    ~Logger() = default;
+    Logger(const Logger&) = default;
+    Logger& operator=(const Logger&) = default;
+    Logger(Logger&&) = default;
+    Logger& operator=(Logger&&) = default;
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] maxEntries - The maximum number of log entries
+     *                         to keep.
+     */
+    explicit Logger(size_t maxEntries) : _maxEntries(maxEntries)
+    {
+        assert(maxEntries != 0);
+    }
+
+    /**
+     * @brief Places an entry in the log and writes it to the journal.
+     *
+     * @param[in] message - The log message
+     *
+     * @param[in] priority - The priority for the journal
+     */
+    void log(const std::string& message, Priority priority = Logger::info)
+    {
+        if (priority == Logger::error)
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(
+                message.c_str());
+        }
+        else
+        {
+            phosphor::logging::log<phosphor::logging::level::INFO>(
+                message.c_str());
+        }
+
+        if (_entries.size() == _maxEntries)
+        {
+            _entries.erase(_entries.begin());
+        }
+
+        // Generate a timestamp
+        auto t = std::time(nullptr);
+        auto tm = *std::localtime(&t);
+
+        // e.g. Sep 22 19:56:32
+        auto timestamp = std::put_time(&tm, "%b %d %H:%M:%S");
+
+        std::ostringstream stream;
+        stream << timestamp;
+        _entries.emplace_back(stream.str(), message);
+    }
+
+    /**
+     * @brief Returns the entries in a JSON array
+     *
+     * @return JSON
+     */
+    const nlohmann::json getLogs() const
+    {
+        return _entries;
+    }
+
+    /**
+     * @brief Writes the JSON to a temporary file and returns the path
+     *        to it.
+     *
+     * Uses a temp file because the only use case for this is for sending
+     * in to an event log where a temp file makes sense, and frankly it
+     * was just easier to encapsulate everything here.
+     *
+     * @return path - The path to the file.
+     */
+    std::filesystem::path saveToTempFile()
+    {
+        using namespace std::literals::string_literals;
+
+        char tmpFile[] = "/tmp/loggertemp.XXXXXX";
+        int fd = mkstemp(tmpFile);
+        if (fd == -1)
+        {
+            throw std::runtime_error{"mkstemp failed!"};
+        }
+
+        std::filesystem::path path{tmpFile};
+
+        nlohmann::json data;
+        data["Logs"] = _entries;
+        auto jsonString = data.dump();
+
+        auto rc = write(fd, jsonString.c_str(), jsonString.size());
+        auto e = errno;
+        close(fd);
+        if (rc == 0)
+        {
+            log(fmt::format("Could not write to temp file {} errno {}", tmpFile,
+                            e),
+                Logger::error);
+            throw std::runtime_error{"Could not write to "s + path.string()};
+        }
+
+        return std::filesystem::path{tmpFile};
+    }
+
+    /**
+     * @brief Deletes all log entries
+     */
+    void clear()
+    {
+        _entries.clear();
+    }
+
+  private:
+    /**
+     * @brief The maximum number of entries to hold
+     */
+    const size_t _maxEntries;
+
+    /**
+     * @brief The vector of <timestamp, message> entries
+     */
+    std::vector<LogEntry> _entries;
+};
+
+} // namespace phosphor::fan
diff --git a/presence/Makefile.am b/presence/Makefile.am
index a26fac9..af66bbd 100644
--- a/presence/Makefile.am
+++ b/presence/Makefile.am
@@ -10,6 +10,7 @@
 	fallback.cpp \
 	fan.cpp \
 	gpio.cpp \
+	logging.cpp \
 	psensor.cpp \
 	tach.cpp \
 	tach_detect.cpp \
diff --git a/presence/logging.cpp b/presence/logging.cpp
new file mode 100644
index 0000000..3945ac9
--- /dev/null
+++ b/presence/logging.cpp
@@ -0,0 +1,30 @@
+/**
+ * Copyright © 2020 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "config.h"
+
+#include "logging.hpp"
+
+namespace phosphor::fan
+{
+
+Logger& getLogger()
+{
+    static Logger logger{NUM_PRESENCE_LOG_ENTRIES};
+
+    return logger;
+}
+
+} // namespace phosphor::fan
diff --git a/presence/logging.hpp b/presence/logging.hpp
new file mode 100644
index 0000000..dd75a96
--- /dev/null
+++ b/presence/logging.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "logger.hpp"
+
+namespace phosphor::fan
+{
+/**
+ * @brief Returns the singleton Logger class
+ *
+ * @return Logger& - The logger
+ */
+Logger& getLogger();
+} // namespace phosphor::fan
diff --git a/test/Makefile.am b/test/Makefile.am
new file mode 100644
index 0000000..ac61577
--- /dev/null
+++ b/test/Makefile.am
@@ -0,0 +1,21 @@
+AM_CPPFLAGS = -iquote$(top_srcdir)
+gtest_cflags = $(PTHREAD_CFLAGS)
+gtest_ldadd = -lgtest -lgtest_main -lgmock $(PTHREAD_LIBS)
+
+check_PROGRAMS = logger_test
+
+TESTS = $(check_PROGRAMS)
+
+logger_test_SOURCES = \
+	logger_test.cpp
+logger_test_CXXFLAGS = \
+	$(gtest_cflags) \
+	${PHOSPHOR_DBUS_INTERFACES_CFLAGS} \
+	$(SDBUSPLUS_CFLAGS)
+logger_test_LDFLAGS = \
+	$(OESDK_TESTCASE_FLAGS)
+logger_test_LDADD = \
+	$(gtest_ldadd) \
+	${PHOSPHOR_DBUS_INTERFACES_LIBS} \
+	$(SDBUSPLUS_LIBS) \
+	$(FMT_LIBS)
diff --git a/test/logger_test.cpp b/test/logger_test.cpp
new file mode 100644
index 0000000..c234b4f
--- /dev/null
+++ b/test/logger_test.cpp
@@ -0,0 +1,59 @@
+#include "logger.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::fan;
+using namespace std::literals::string_literals;
+
+TEST(LoggerTest, Test)
+{
+    const auto logSize = 5;
+
+    Logger logger{logSize};
+
+    for (int i = 0; i < logSize; i++)
+    {
+        logger.log("Test Message "s + std::to_string(i));
+    }
+
+    auto messages = logger.getLogs();
+
+    ASSERT_EQ(messages.size(), logSize);
+
+    EXPECT_EQ((messages[0][1].get<std::string>()), "Test Message 0");
+    EXPECT_EQ((messages[1][1].get<std::string>()), "Test Message 1");
+    EXPECT_EQ((messages[2][1].get<std::string>()), "Test Message 2");
+    EXPECT_EQ((messages[3][1].get<std::string>()), "Test Message 3");
+    EXPECT_EQ((messages[4][1].get<std::string>()), "Test Message 4");
+
+    // There isn't really a way to verify the timestamp, but
+    // it can at least be printed.
+    for (const auto& msg : messages)
+    {
+        std::cout << "Timestamp: " << msg[0] << "\n";
+    }
+
+    // Add another message, it should purge the first one
+    logger.log("New Message");
+
+    messages = logger.getLogs();
+    ASSERT_EQ(messages.size(), logSize);
+
+    // Check the first and last
+    EXPECT_EQ((messages[0][1].get<std::string>()), "Test Message 1");
+    EXPECT_EQ((messages[4][1].get<std::string>()), "New Message");
+
+    auto path = logger.saveToTempFile();
+    ASSERT_TRUE(std::filesystem::exists(path));
+
+    std::ifstream file{path};
+
+    // check that valid JSON was written
+    auto newJSON = nlohmann::json::parse(file);
+    EXPECT_EQ(newJSON["Logs"].size(), logSize);
+    std::filesystem::remove(path);
+
+    logger.clear();
+    messages = logger.getLogs();
+    EXPECT_TRUE(messages.empty());
+}