diff --git a/extensions/openpower-pels/repository.hpp b/extensions/openpower-pels/repository.hpp
index 31c569c..0b5cab1 100644
--- a/extensions/openpower-pels/repository.hpp
+++ b/extensions/openpower-pels/repository.hpp
@@ -425,6 +425,26 @@
         return _lastPelID;
     }
 
+    /**
+     * @brief Get the LogID based on the given ObmcLogId or PelId.
+     *
+     * @param[in] id - The ID to find the LogID.
+     *
+     * @return The LogID or an empty optional if not found.
+     *
+     * @note The returned LogID is the fully filled in LogID, i.e.
+     * it has both the PEL and OpenBMC Log IDs, unlike the passed in LogID
+     * which can just have one or the other.
+     */
+    std::optional<LogID> getLogID(const LogID& id) const
+    {
+        if (auto logID = findPEL(id); logID != _pelAttributes.end())
+        {
+            return logID->first;
+        }
+        return std::nullopt;
+    }
+
   private:
     using PELUpdateFunc = std::function<void(PEL&)>;
 
diff --git a/test/openpower-pels/repository_test.cpp b/test/openpower-pels/repository_test.cpp
index 42a921b..7aa0d0d 100644
--- a/test/openpower-pels/repository_test.cpp
+++ b/test/openpower-pels/repository_test.cpp
@@ -960,3 +960,54 @@
     EXPECT_FALSE(repo.sizeWarning());
     EXPECT_FALSE(fs::exists(archivePath));
 }
+
+TEST_F(RepositoryTest, GetLogIDFoundTC)
+{
+    // Add and Check the created LogId
+
+    Repository repo{repoPath};
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto pel = std::make_unique<PEL>(data, 1);
+
+    pel->assignID();
+
+    repo.add(pel);
+
+    // Getting by PEL Id
+    Repository::LogID idWithPelId{Repository::LogID::Pel(pel->id())};
+    auto logID = repo.getLogID(idWithPelId);
+    ASSERT_TRUE(logID.has_value());
+    EXPECT_EQ(logID->obmcID.id, pel->obmcLogID());
+    EXPECT_EQ(logID->pelID.id, pel->id());
+
+    // Getting by OBMC Event Log Id
+    Repository::LogID idWithObmcLogId{
+        Repository::LogID::Obmc(pel->obmcLogID())};
+    logID = repo.getLogID(idWithObmcLogId);
+    ASSERT_TRUE(logID.has_value());
+    EXPECT_EQ(logID->obmcID.id, pel->obmcLogID());
+    EXPECT_EQ(logID->pelID.id, pel->id());
+}
+
+TEST_F(RepositoryTest, GetLogIDNotFoundTC)
+{
+    // Add and Check the created LogId
+
+    Repository repo{repoPath};
+    auto data = pelDataFactory(TestPELType::pelSimple);
+    auto pel = std::make_unique<PEL>(data, 1);
+
+    pel->assignID();
+
+    repo.add(pel);
+
+    // Getting by invalid PEL Id
+    Repository::LogID idWithPelId{Repository::LogID::Pel(0xFFFFFFFF)};
+    auto logID = repo.getLogID(idWithPelId);
+    ASSERT_TRUE(!logID.has_value());
+
+    // Getting by invalid OBMC Event Log ID
+    Repository::LogID idWithObmcLogId{Repository::LogID::Obmc(0xFFFFFFFF)};
+    logID = repo.getLogID(idWithObmcLogId);
+    ASSERT_TRUE(!logID.has_value());
+}
