diff --git a/Makefile.am b/Makefile.am
index 82d6c86..e1ec5c3 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -40,7 +40,8 @@
 	elog-process-metadata.cpp \
 	elog_meta.cpp \
 	elog_serialize.cpp \
-	sdjournal.cpp
+	sdjournal.cpp \
+	extensions.cpp
 
 # Be sure to build needed files before compiling
 BUILT_SOURCES = \
@@ -75,6 +76,10 @@
 		$(SDBUSPLUS_CFLAGS) \
 		$(PHOSPHOR_DBUS_INTERFACES_CFLAGS)
 
+
+include extensions/extensions.mk
+
+
 xyz/openbmc_project/Logging/Internal/Manager/server.cpp: xyz/openbmc_project/Logging/Internal/Manager.interface.yaml xyz/openbmc_project/Logging/Internal/Manager/server.hpp
 	@mkdir -p `dirname $@`
 	$(SDBUSPLUSPLUS) -r $(srcdir) interface server-cpp xyz.openbmc_project.Logging.Internal.Manager > $@
diff --git a/README.md b/README.md
index f8ab729..665fbfc 100644
--- a/README.md
+++ b/README.md
@@ -242,5 +242,102 @@
 #### Local build
 * During local build use --prefix=/usr for the configure script.
 
+## Event Log Extensions
+
+The extension concept is a way to allow code that creates other formats of
+error logs besides phosphor-logging's event logs to still reside in the
+phosphor-log-manager application.
+
+The extension code lives in the `extensions/<extension>` subdirectories,
+and is enabled with a `--enable-<extension>` configure flag.  The
+extension code won't compile unless enabled with this flag.
+
+Extensions can register themselves to have functions called at the following
+points using the REGISTER_EXTENSION_FUNCTION macro.
+* On startup
+   * Function type void(internal::Manager&)
+* After an event log is created
+   * Function type void(args)
+   * The args are:
+     * const std::string& - The Message property
+     * uin32_t - The event log ID
+     * uint64_t - The event log timestamp
+     * Level - The event level
+     * const AdditionalDataArg& - the additional data
+     * const AssociationEndpointsArg& - Association endpoints (callouts)
+* Before an event log is deleted, to check if it is allowed.
+   * Function type void(std::uint32_t, bool&) that takes the event ID
+* After an event log is deleted
+   * Function type void(std::uint32_t) that takes the event ID
+
+Using these callback points, they can create their own event log for each
+OpenBMC event log that is created, and delete these logs when the corresponding
+OpenBMC event log is deleted.
+
+In addition, an extension has the option of disabling phosphor-logging's
+default error log capping policy so that it can use its own.  The macro
+DISABLE_LOG_ENTRY_CAPS() is used for that.
+
+### Motivation
+
+The reason for adding support for extensions inside the phosphor-log-manager
+daemon as opposed to just creating new daemons that listen for D-Bus signals is
+to allow interactions that would be complicated or expensive if just done over
+D-Bus, such as:
+* Allowing for custom old log retention algorithms.
+* Prohibiting manual deleting of certain logs based on an extension's
+  requirements.
+
+### Creating extensions
+
+1. Add a new flag to configure.ac to enable the extension:
+```
+AC_ARG_ENABLE([foo-extension],
+              AS_HELP_STRING([--enable-foo-extension],
+                             [Create Foo logs]))
+AM_CONDITIONAL([ENABLE_FOO_EXTENSION],
+               [test "x$enable_foo_extension" == "xyes"])
+```
+2. Add the code in `extensions/<extension>/`.
+3. Create a makefile include to add the new code to phosphor-log-manager:
+```
+phosphor_log_manager_SOURCES += \
+        extensions/foo/foo.cpp
+```
+3. In `extensions/extensions.mk`, add the makefile include:
+```
+if ENABLE_FOO_EXTENSION
+include extensions/foo/foo.mk
+endif
+```
+4. In the extension code, register the functions to call and optionally disable
+   log capping using the provided macros:
+```
+DISABLE_LOG_ENTRY_CAPS();
+
+void fooStartup(internal::Manager& manager)
+{
+    // Initialize
+}
+
+REGISTER_EXTENSION_FUNCTION(fooStartup);
+
+void fooCreate(const std::string& message, uint32_t id, uint64_t timestamp,
+               Entry::Level severity, const AdditionalDataArg& additionalData,
+               const AssociationEndpointsArg& assocs)
+{
+    // Create a different type of error log based on 'entry'.
+}
+
+REGISTER_EXTENSION_FUNCTION(fooCreate);
+
+void fooRemove(uint32_t id)
+{
+    // Delete the extension error log that corresponds to 'id'.
+}
+
+REGISTER_EXTENSION_FUNCTION(fooRemove);
+```
+
 **Reference**
 * https://github.com/openbmc/openpower-debug-collector/blob/master/README.md
diff --git a/configure.ac b/configure.ac
index f918ba6..3139382 100644
--- a/configure.ac
+++ b/configure.ac
@@ -146,6 +146,11 @@
 AC_DEFINE(SYSTEMD_PATH, "/org/freedesktop/systemd1", [systemd path.])
 AC_DEFINE(SYSTEMD_INTERFACE, "org.freedesktop.systemd1.Manager", [systemd interface.])
 
+AC_ARG_ENABLE([openpower-pel-extension],
+    AS_HELP_STRING([--enable-openpower-pel-extension], [Create PELs])
+)
+AM_CONDITIONAL([ENABLE_PEL_EXTENSION], [test "x$enable_openpower_pel_extension" == "xyes"])
+
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_FILES([Makefile test/Makefile phosphor-rsyslog-config/Makefile])
 AC_CONFIG_FILES([phosphor-logging.pc])
diff --git a/extensions.cpp b/extensions.cpp
new file mode 100644
index 0000000..ffeb059
--- /dev/null
+++ b/extensions.cpp
@@ -0,0 +1,16 @@
+#include "extensions.hpp"
+
+namespace phosphor
+{
+namespace logging
+{
+
+StartupFunctions Extensions::startupFunctions{};
+CreateFunctions Extensions::createFunctions{};
+DeleteFunctions Extensions::deleteFunctions{};
+DeleteProhibitedFunctions Extensions::deleteProhibitedFunctions{};
+Extensions::DefaultErrorCaps Extensions::defaultErrorCaps =
+    Extensions::DefaultErrorCaps::enable;
+
+} // namespace logging
+} // namespace phosphor
diff --git a/extensions.hpp b/extensions.hpp
new file mode 100644
index 0000000..3897894
--- /dev/null
+++ b/extensions.hpp
@@ -0,0 +1,246 @@
+#pragma once
+
+#include "elog_entry.hpp"
+#include "log_manager.hpp"
+
+#include <functional>
+#include <vector>
+
+namespace phosphor
+{
+namespace logging
+{
+
+/**
+ * @brief The function type that will be called on start up.
+ * @param[in] internal::Manager& - A reference to the Manager class.
+ */
+using StartupFunction = std::function<void(internal::Manager&)>;
+
+using AdditionalDataArg = std::vector<std::string>;
+using AssociationEndpointsArg = std::vector<std::string>;
+/**
+ *  @brief The function type that will be called after an event log
+ *         is created.
+ * @param[in] const std::string& - The Message property
+ * @param[in] uin32_t - The event log ID
+ * @param[in] uint64_t - The event log timestamp
+ * @param[in] Level - The event level
+ * @param[in] const AdditionalDataArg&) - the additional data
+ * @param[in] const AssociationEndpoints& - Association endpoints (callouts)
+ */
+using CreateFunction = std::function<void(
+    const std::string&, uint32_t, uint64_t, Entry::Level,
+    const AdditionalDataArg&, const AssociationEndpointsArg&)>;
+
+/**
+ * @brief The function type that will be called after an event log is deleted.
+ * @param[in] uint32_t - The event log ID
+ */
+using DeleteFunction = std::function<void(uint32_t)>;
+
+/**
+ * @brief The function type that will to check if an event log is prohibited
+ *        from being deleted.
+ * @param[in] uint32_t - The event log ID
+ * @param[out] bool - set to true if the delete is prohibited
+ */
+using DeleteProhibitedFunction = std::function<void(uint32_t, bool&)>;
+
+using StartupFunctions = std::vector<StartupFunction>;
+using CreateFunctions = std::vector<CreateFunction>;
+using DeleteFunctions = std::vector<DeleteFunction>;
+using DeleteProhibitedFunctions = std::vector<DeleteProhibitedFunction>;
+
+/**
+ * @brief Register an extension hook function
+ *
+ * Call this macro at global scope to register a hook to call.
+ * Each hook point has a unique function prototype.
+ */
+#define REGISTER_EXTENSION_FUNCTION(func)                                      \
+    namespace func##_ns                                                        \
+    {                                                                          \
+        Extensions e{func};                                                    \
+    }
+
+/**
+ * @brief Disable default error log capping
+ *
+ * Call this macro at global scope to tell phosphor-logging to disable its
+ * default error log capping algorithm, so that an extension can use its own
+ * instead.
+ */
+#define DISABLE_LOG_ENTRY_CAPS()                                               \
+    namespace disable_caps##_ns                                                \
+    {                                                                          \
+        Extensions e{Extensions::DefaultErrorCaps::disable};                   \
+    }
+
+/**
+ * @class Extensions
+ *
+ * This class manages any error log extensions.  Extensions can register
+ * their hook functions with this class with the provided macros so that they
+ * are then able to create their own types of logs based on the native logs.
+ *
+ * The class should only be constructed at a global scope via the macros.
+ */
+class Extensions
+{
+  public:
+    Extensions() = delete;
+    ~Extensions() = default;
+    Extensions(const Extensions&) = delete;
+    Extensions& operator=(const Extensions&) = delete;
+    Extensions(Extensions&&) = delete;
+    Extensions& operator=(Extensions&&) = delete;
+
+    enum class DefaultErrorCaps
+    {
+        disable,
+        enable
+    };
+
+    /**
+     * @brief Constructor to register a startup function
+     *
+     * Functions registered with this contructor will be called
+     * when phosphor-log-manager starts up.
+     *
+     * @param[in] func - The startup function to register
+     */
+    explicit Extensions(StartupFunction func)
+    {
+        startupFunctions.push_back(func);
+    }
+
+    /**
+     * @brief Constructor to register a create function
+     *
+     * Functions registered with this contructor will be called
+     * after phosphor-log-manager creates an event log.
+     *
+     * @param[in] func - The create function to register
+     */
+    explicit Extensions(CreateFunction func)
+    {
+        createFunctions.push_back(func);
+    }
+
+    /**
+     * @brief Constructor to register a delete function
+     *
+     * Functions registered with this contructor will be called
+     * after phosphor-log-manager deletes an event log.
+     *
+     * @param[in] func - The delete function to register
+     */
+    explicit Extensions(DeleteFunction func)
+    {
+        deleteFunctions.push_back(func);
+    }
+
+    /**
+     * @brief Constructor to register a delete prohibition function
+     *
+     * Functions registered with this contructor will be called
+     * before phosphor-log-manager deletes an event log to ensure
+     * deleting the log is allowed.
+     *
+     * @param[in] func - The function to register
+     */
+    explicit Extensions(DeleteProhibitedFunction func)
+    {
+        deleteProhibitedFunctions.push_back(func);
+    }
+
+    /**
+     * @brief Constructor to disable event log capping
+     *
+     * This constructor should only be called by the
+     * DISABLE_LOG_ENTRY_CAPS macro to disable the default
+     * event log capping so that the extension can use their own.
+     *
+     * @param[in] defaultCaps - Enable or disable default capping.
+     */
+    explicit Extensions(DefaultErrorCaps defaultCaps)
+    {
+        defaultErrorCaps = defaultCaps;
+    }
+
+    /**
+     * @brief Returns the Startup functions
+     * @return StartupFunctions - the Startup functions
+     */
+    static StartupFunctions& getStartupFunctions()
+    {
+        return startupFunctions;
+    }
+
+    /**
+     * @brief Returns the Create functions
+     * @return CreateFunctions - the Create functions
+     */
+    static CreateFunctions& getCreateFunctions()
+    {
+        return createFunctions;
+    }
+
+    /**
+     * @brief Returns the Delete functions
+     * @return DeleteFunctions - the Delete functions
+     */
+    static DeleteFunctions& getDeleteFunctions()
+    {
+        return deleteFunctions;
+    }
+
+    /**
+     * @brief Returns the DeleteProhibited functions
+     * @return DeleteProhibitedFunctions - the DeleteProhibited functions
+     */
+    static DeleteProhibitedFunctions& getDeleteProhibitedFunctions()
+    {
+        return deleteProhibitedFunctions;
+    }
+
+    /**
+     * @brief Say if the default log capping policy should be disabled
+     * @return bool - true if it should be disabled
+     */
+    static bool disableDefaultLogCaps()
+    {
+        return defaultErrorCaps == DefaultErrorCaps::disable;
+    }
+
+  private:
+    /**
+     * @brief Vector of functions to call on app startup.
+     */
+    static StartupFunctions startupFunctions;
+
+    /**
+     * @brief Vector of functions to call after creating an event log.
+     */
+    static CreateFunctions createFunctions;
+
+    /**
+     * @brief Vector of functions to call after deleting an event log.
+     */
+    static DeleteFunctions deleteFunctions;
+
+    /**
+     * @brief Vector of functions to call to check if deleting a
+     *        particular event log is prohibited.
+     */
+    static DeleteProhibitedFunctions deleteProhibitedFunctions;
+
+    /**
+     * @brief If default log capping should be disabled.
+     */
+    static DefaultErrorCaps defaultErrorCaps;
+};
+
+} // namespace logging
+} // namespace phosphor
diff --git a/extensions/extensions.mk b/extensions/extensions.mk
new file mode 100644
index 0000000..e7648a8
--- /dev/null
+++ b/extensions/extensions.mk
@@ -0,0 +1,3 @@
+if ENABLE_PEL_EXTENSION
+include extensions/openpower-pels/openpower-pels.mk
+endif
diff --git a/extensions/openpower-pels/entry_points.cpp b/extensions/openpower-pels/entry_points.cpp
new file mode 100644
index 0000000..1b29ec5
--- /dev/null
+++ b/extensions/openpower-pels/entry_points.cpp
@@ -0,0 +1,42 @@
+#include "elog_entry.hpp"
+#include "extensions.hpp"
+#include "sdbusplus/bus.hpp"
+
+namespace openpower
+{
+namespace pels
+{
+
+using namespace phosphor::logging;
+
+DISABLE_LOG_ENTRY_CAPS();
+
+void pelStartup(internal::Manager& logManager)
+{
+}
+
+REGISTER_EXTENSION_FUNCTION(pelStartup);
+
+void pelCreate(const std::string& message, uint32_t id, uint64_t timestamp,
+               Entry::Level severity, const AdditionalDataArg& additionalData,
+               const AssociationEndpointsArg& assocs)
+{
+}
+
+REGISTER_EXTENSION_FUNCTION(pelCreate);
+
+void pelDelete(uint32_t id)
+{
+}
+
+REGISTER_EXTENSION_FUNCTION(pelDelete);
+
+void pelDeleteProhibited(uint32_t id, bool& prohibited)
+{
+    prohibited = false;
+}
+
+REGISTER_EXTENSION_FUNCTION(pelDeleteProhibited);
+
+} // namespace pels
+} // namespace openpower
diff --git a/extensions/openpower-pels/openpower-pels.mk b/extensions/openpower-pels/openpower-pels.mk
new file mode 100644
index 0000000..717fdca
--- /dev/null
+++ b/extensions/openpower-pels/openpower-pels.mk
@@ -0,0 +1,3 @@
+phosphor_log_manager_SOURCES += \
+	extensions/openpower-pels/entry_points.cpp
+
diff --git a/log_manager.cpp b/log_manager.cpp
index 3dc14d7..0f4e57c 100644
--- a/log_manager.cpp
+++ b/log_manager.cpp
@@ -5,6 +5,7 @@
 #include "elog_entry.hpp"
 #include "elog_meta.hpp"
 #include "elog_serialize.hpp"
+#include "extensions.hpp"
 
 #include <poll.h>
 #include <sys/inotify.h>
@@ -12,6 +13,7 @@
 #include <systemd/sd-journal.h>
 #include <unistd.h>
 
+#include <cassert>
 #include <chrono>
 #include <cstdio>
 #include <cstring>
@@ -77,20 +79,24 @@
 void Manager::_commit(uint64_t transactionId, std::string&& errMsg,
                       Entry::Level errLvl)
 {
-    if (errLvl < Entry::sevLowerLimit)
+    if (!Extensions::disableDefaultLogCaps())
     {
-        if (realErrors.size() >= ERROR_CAP)
+        if (errLvl < Entry::sevLowerLimit)
         {
-            erase(realErrors.front());
+            if (realErrors.size() >= ERROR_CAP)
+            {
+                erase(realErrors.front());
+            }
+        }
+        else
+        {
+            if (infoErrors.size() >= ERROR_INFO_CAP)
+            {
+                erase(infoErrors.front());
+            }
         }
     }
-    else
-    {
-        if (infoErrors.size() >= ERROR_INFO_CAP)
-        {
-            erase(infoErrors.front());
-        }
-    }
+
     constexpr const auto transactionIdVar = "TRANSACTION_ID";
     // Length of 'TRANSACTION_ID' string.
     constexpr const auto transactionIdVarSize = std::strlen(transactionIdVar);
@@ -217,9 +223,39 @@
                                      std::move(additionalData),
                                      std::move(objects), fwVersion, *this);
     serialize(*e);
+
+    doExtensionLogCreate(*e);
+
     entries.insert(std::make_pair(entryId, std::move(e)));
 }
 
+void Manager::doExtensionLogCreate(const Entry& entry)
+{
+    // Make the association <endpointpath>/<endpointtype> paths
+    std::vector<std::string> assocs;
+    for (const auto& [forwardType, reverseType, endpoint] :
+         entry.associations())
+    {
+        std::string e{endpoint};
+        e += '/' + reverseType;
+        assocs.push_back(e);
+    }
+
+    for (auto& create : Extensions::getCreateFunctions())
+    {
+        try
+        {
+            create(entry.message(), entry.id(), entry.timestamp(),
+                   entry.severity(), entry.additionalData(), assocs);
+        }
+        catch (std::exception& e)
+        {
+            log<level::ERR>("An extension's create function threw an exception",
+                            phosphor::logging::entry("ERROR=%s", e.what()));
+        }
+    }
+}
+
 void Manager::processMetadata(const std::string& errorName,
                               const std::vector<std::string>& additionalData,
                               AssociationList& objects) const
@@ -246,6 +282,27 @@
     auto entryFound = entries.find(entryId);
     if (entries.end() != entryFound)
     {
+        for (auto& func : Extensions::getDeleteProhibitedFunctions())
+        {
+            try
+            {
+                bool prohibited = false;
+                func(entryId, prohibited);
+                if (prohibited)
+                {
+                    // Future work remains to throw an error here.
+                    return;
+                }
+            }
+            catch (std::exception& e)
+            {
+                log<level::ERR>(
+                    "An extension's deleteProhibited function threw "
+                    "an exception",
+                    entry("ERROR=%s", e.what()));
+            }
+        }
+
         // Delete the persistent representation of this error.
         fs::path errorPath(ERRLOG_PERSIST_PATH);
         errorPath /= std::to_string(entryId);
@@ -267,6 +324,20 @@
             removeId(realErrors, entryId);
         }
         entries.erase(entryFound);
+
+        for (auto& remove : Extensions::getDeleteFunctions())
+        {
+            try
+            {
+                remove(entryId);
+            }
+            catch (std::exception& e)
+            {
+                log<level::ERR>("An extension's delete function threw an "
+                                "exception",
+                                entry("ERROR=%s", e.what()));
+            }
+        }
     }
     else
     {
diff --git a/log_manager.hpp b/log_manager.hpp
index e6714af..4b09952 100644
--- a/log_manager.hpp
+++ b/log_manager.hpp
@@ -154,6 +154,14 @@
      */
     static std::string readFWVersion();
 
+    /** @brief Call any create() functions provided by any extensions.
+     *  This is called right after an event log is created to allow
+     *  extensions to create their own log based on this one.
+     *
+     *  @param[in] entry - the new event log entry
+     */
+    void doExtensionLogCreate(const Entry& entry);
+
     /** @brief Persistent sdbusplus DBus bus connection. */
     sdbusplus::bus::bus& busLog;
 
diff --git a/log_manager_main.cpp b/log_manager_main.cpp
index 48a7dee..ddcb063 100644
--- a/log_manager_main.cpp
+++ b/log_manager_main.cpp
@@ -1,5 +1,6 @@
 #include "config.h"
 
+#include "extensions.hpp"
 #include "log_manager.hpp"
 
 #include <experimental/filesystem>
@@ -25,6 +26,20 @@
 
     bus.request_name(BUSNAME_LOGGING);
 
+    for (auto& startup : phosphor::logging::Extensions::getStartupFunctions())
+    {
+        try
+        {
+            startup(iMgr);
+        }
+        catch (std::exception& e)
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(
+                "An extension's startup function threw an exception",
+                phosphor::logging::entry("ERROR=%s", e.what()));
+        }
+    }
+
     while (true)
     {
         bus.process_discard();
diff --git a/test/Makefile.am b/test/Makefile.am
index 7fd38d1..a55e9a9 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -9,7 +9,8 @@
 	remote_logging_test_address \
 	remote_logging_test_port \
 	remote_logging_test_config \
-	sdjournal_mock_test
+	sdjournal_mock_test \
+	extensions_test
 
 test_cppflags = \
 	-Igtest \
@@ -38,7 +39,8 @@
 	$(top_builddir)/elog_meta.o \
 	$(top_builddir)/elog-lookup.o \
 	$(top_builddir)/elog-process-metadata.o \
-	$(top_builddir)/sdjournal.o
+	$(top_builddir)/sdjournal.o \
+	$(top_builddir)/extensions.o
 
 remote_logging_test_ldadd = \
 	$(top_builddir)/phosphor-rsyslog-config/server-conf.o \
@@ -98,5 +100,19 @@
 sdjournal_mock_test_LDADD = $(top_builddir)/sdjournal.o
 sdjournal_mock_test_LDFLAGS = $(test_ldflags)
 
+extensions_test_CPPFLAGS = $(test_cppflags)
+extensions_test_CXXFLAGS = $(test_cxxflags)
+extensions_test_SOURCES = extensions_test.cpp
+extensions_test_LDADD = \
+	$(top_builddir)/elog_entry.o \
+	$(top_builddir)/elog-lookup.o \
+	$(top_builddir)/elog_meta.o \
+	$(top_builddir)/elog-process-metadata.o \
+	$(top_builddir)/elog_serialize.o \
+	$(top_builddir)/log_manager.o \
+	$(top_builddir)/org.openbmc.Associations.o \
+	$(top_builddir)/xyz/openbmc_project/Logging/Internal/Manager/server.o
+extensions_test_LDFLAGS = $(test_ldflags) -lstdc++fs
+
 # TODO Remove once the test-case failure is resolved openbmc/phosphor-logging#11
 XFAIL_TESTS = elog_errorwrap_test
diff --git a/test/extensions_test.cpp b/test/extensions_test.cpp
new file mode 100644
index 0000000..17c3395
--- /dev/null
+++ b/test/extensions_test.cpp
@@ -0,0 +1,98 @@
+#include "elog_entry.hpp"
+#include "extensions.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::logging;
+
+// gtest doesn't like this happening in another file, so do it here.
+StartupFunctions Extensions::startupFunctions{};
+CreateFunctions Extensions::createFunctions{};
+DeleteFunctions Extensions::deleteFunctions{};
+DeleteProhibitedFunctions Extensions::deleteProhibitedFunctions{};
+Extensions::DefaultErrorCaps Extensions::defaultErrorCaps =
+    Extensions::DefaultErrorCaps::enable;
+
+void startup1(internal::Manager& manager)
+{
+}
+
+void startup2(internal::Manager& manager)
+{
+}
+
+void create1(const std::string& message, uint32_t id, uint64_t timestamp,
+             Entry::Level severity, const AdditionalDataArg& additionalData,
+             const AssociationEndpointsArg& assocs)
+{
+}
+
+void create2(const std::string& message, uint32_t id, uint64_t timestamp,
+             Entry::Level severity, const AdditionalDataArg& additionalData,
+             const AssociationEndpointsArg& assocs)
+{
+}
+
+void deleteLog1(uint32_t id)
+{
+}
+
+void deleteLog2(uint32_t id)
+{
+}
+
+void deleteProhibited1(uint32_t id, bool& prohibited)
+{
+    prohibited = true;
+}
+
+void deleteProhibited2(uint32_t id, bool& prohibited)
+{
+    prohibited = true;
+}
+
+DISABLE_LOG_ENTRY_CAPS();
+REGISTER_EXTENSION_FUNCTION(startup1);
+REGISTER_EXTENSION_FUNCTION(startup2);
+REGISTER_EXTENSION_FUNCTION(create1);
+REGISTER_EXTENSION_FUNCTION(create2);
+REGISTER_EXTENSION_FUNCTION(deleteProhibited1);
+REGISTER_EXTENSION_FUNCTION(deleteProhibited2);
+REGISTER_EXTENSION_FUNCTION(deleteLog1);
+REGISTER_EXTENSION_FUNCTION(deleteLog2);
+
+TEST(ExtensionsTest, FunctionCallTest)
+{
+    auto bus = sdbusplus::bus::new_default();
+    internal::Manager manager(bus, "testpath");
+
+    EXPECT_EQ(Extensions::getStartupFunctions().size(), 2);
+    for (auto& s : Extensions::getStartupFunctions())
+    {
+        s(manager);
+    }
+
+    AdditionalDataArg ad;
+    AssociationEndpointsArg assocs;
+    EXPECT_EQ(Extensions::getCreateFunctions().size(), 2);
+    for (auto& c : Extensions::getCreateFunctions())
+    {
+        c("test", 5, 6, Entry::Level::Informational, ad, assocs);
+    }
+
+    EXPECT_EQ(Extensions::getDeleteFunctions().size(), 2);
+    for (auto& d : Extensions::getDeleteFunctions())
+    {
+        d(5);
+    }
+
+    EXPECT_EQ(Extensions::getDeleteProhibitedFunctions().size(), 2);
+    for (auto& p : Extensions::getDeleteProhibitedFunctions())
+    {
+        bool prohibited = false;
+        p(5, prohibited);
+        EXPECT_TRUE(prohibited);
+    }
+
+    EXPECT_TRUE(Extensions::disableDefaultLogCaps());
+}