diff --git a/src/log_manager.cpp b/src/log_manager.cpp
index 9932408..9bc699d 100644
--- a/src/log_manager.cpp
+++ b/src/log_manager.cpp
@@ -1,17 +1,12 @@
-#include "../include/featherlog/log_manager.hpp"
+#include <featherlog/log_manager.hpp>
 
-namespace flog
-{
-
-
-    inline std::shared_ptr<LogManager> LogManager::create()
-    {
+namespace flog {
+    std::shared_ptr<LogManager> LogManager::create() {
         // ReSharper disable once CppDFAMemoryLeak
         return std::shared_ptr<LogManager>(new LogManager());
     }
 
-    inline LogManager::~LogManager()
-    {
+    LogManager::~LogManager() {
         {
             std::lock_guard lock(m_loggersMutex);
             m_loggers.clear();
@@ -22,27 +17,22 @@ namespace flog
         }
     }
 
-    inline LogLevel LogManager::get_min_log_level() const noexcept
-    {
+    LogLevel LogManager::get_min_log_level() const noexcept {
         return m_minLogLevel.load(std::memory_order_relaxed);
     }
 
-    inline void LogManager::set_min_log_level(const LogLevel level) noexcept
-    {
+    void LogManager::set_min_log_level(const LogLevel level) noexcept {
         m_minLogLevel.store(level, std::memory_order_relaxed);
     }
 
-    inline void LogManager::add_outputter(std::unique_ptr<LogOutputter> outputter)
-    {
+    void LogManager::add_outputter(std::unique_ptr<LogOutputter> outputter) {
         std::lock_guard lock(m_logOutputtersMutex);
         m_logOutputters.push_back(std::move(outputter));
     }
 
-    inline std::shared_ptr<Logger> LogManager::get_logger(const std::string& name)
-    {
+    std::shared_ptr<Logger> LogManager::get_logger(const std::string &name) {
         std::lock_guard lock(m_loggersMutex);
-        if (const auto it = m_loggers.find(name); it != m_loggers.end())
-        {
+        if (const auto it = m_loggers.find(name); it != m_loggers.end()) {
             return it->second;
         }
 
@@ -51,53 +41,24 @@ namespace flog
         return logger;
     }
 
-    inline size_t LogManager::clean_unused_loggers()
-    {
+    size_t LogManager::clean_unused_loggers() {
         std::lock_guard lock(m_loggersMutex);
         size_t count = 0;
-        for (auto it = m_loggers.begin(); it != m_loggers.end();)
-        {
-            if (it->second.use_count() == 1)
-            {
+        for (auto it = m_loggers.begin(); it != m_loggers.end();) {
+            if (it->second.use_count() == 1) {
                 it = m_loggers.erase(it);
                 count += 1;
-            }
-            else
-            {
+            } else {
                 ++it;
             }
         }
         return count;
     }
 
-    inline void LogManager::print_log(const LogMessage& message) const
-    {
+    void LogManager::print_log(const LogMessage &message) const {
         std::shared_lock lock(m_logOutputtersMutex);
-        for (auto& outputter : m_logOutputters)
-        {
+        for (auto &outputter: m_logOutputters) {
             outputter->write(message);
         }
     }
-
-    inline LoggerCallback::LoggerCallback(const std::weak_ptr<LogManager>& logManager) noexcept : m_logManager(
-        logManager)
-    {
-    }
-
-    inline void LoggerCallback::print_log(const LogMessage& message) const
-    {
-        if (const auto mgr = m_logManager.lock())
-        {
-            mgr->print_log(message);
-        }
-    }
-
-    inline LogLevel LoggerCallback::get_min_log_level() const noexcept
-    {
-        if (const auto mgr = m_logManager.lock())
-        {
-            return mgr->get_min_log_level();
-        }
-        return LogLevel::OFF;
-    }
 }