diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 00000000..13566b81
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/dataSources.local.xml b/.idea/dataSources.local.xml
index bbe4ff1a..3702f623 100644
--- a/.idea/dataSources.local.xml
+++ b/.idea/dataSources.local.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="dataSourceStorageLocal" created-in="PY-233.13763.11">
+  <component name="dataSourceStorageLocal" created-in="PY-243.24978.54">
     <data-source name="unmanic.db" uuid="2c141027-e9fa-4c33-9911-3ea8aa77ac23">
       <database-info product="SQLite" version="3.43.0" jdbc-version="4.2" driver-name="SQLite JDBC" driver-version="3.43.0.0" dbms="SQLITE" exact-version="3.43.0" exact-driver-version="3.43">
         <identifier-quote-string>&quot;</identifier-quote-string>
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index f27bdf62..28237969 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -15,5 +15,15 @@
         </value>
       </option>
     </inspection_tool>
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="2">
+            <item index="0" class="java.lang.String" itemvalue="peewee_migrate" />
+            <item index="1" class="java.lang.String" itemvalue="requests_toolbelt" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
   </profile>
 </component>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index f847eee4..6c3f707e 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -3,7 +3,7 @@
   <component name="Black">
     <option name="sdkName" value="Python 3.10 (unmanic)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (unmanic)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (unmanic)" project-jdk-type="Python SDK" />
   <component name="PythonCompatibilityInspectionAdvertiser">
     <option name="version" value="3" />
   </component>
diff --git a/.idea/runConfigurations/Run_Unmanic.xml b/.idea/runConfigurations/Run_Unmanic.xml
index c50b9b4a..97d8235e 100644
--- a/.idea/runConfigurations/Run_Unmanic.xml
+++ b/.idea/runConfigurations/Run_Unmanic.xml
@@ -1,12 +1,13 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Run Unmanic" type="PythonConfigurationType" factoryName="Python">
+  <configuration default="false" name="Run Unmanic" type="PythonConfigurationType" factoryName="Python" show_console_on_std_err="true" show_console_on_std_out="true">
+    <log_file alias="$PROJECT_DIR$/dev_environment/.unmanic/logs/*.log" path="$PROJECT_DIR$/dev_environment/.unmanic/logs/*.log" show_all="true" />
     <module name="unmanic" />
     <option name="ENV_FILES" value="" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
     <envs>
-      <env name="HOME_DIR" value="./dev_environment" />
       <env name="PYTHONUNBUFFERED" value="1" />
+      <env name="HOME_DIR" value="./dev_environment" />
     </envs>
     <option name="SDK_HOME" value="$PROJECT_DIR$/venv/bin/python" />
     <option name="SDK_NAME" value="Python 3.12 (unmanic)" />
diff --git a/.idea/runConfigurations/Run_Unmanic_Dev.xml b/.idea/runConfigurations/Run_Unmanic_Dev.xml
index f1ee8aae..7248c5d9 100644
--- a/.idea/runConfigurations/Run_Unmanic_Dev.xml
+++ b/.idea/runConfigurations/Run_Unmanic_Dev.xml
@@ -1,12 +1,13 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Run Unmanic Dev" type="PythonConfigurationType" factoryName="Python">
+  <configuration default="false" name="Run Unmanic Dev" type="PythonConfigurationType" factoryName="Python" show_console_on_std_err="true" show_console_on_std_out="true">
+    <log_file alias="$PROJECT_DIR$/dev_environment/.unmanic/logs/*.log" path="$PROJECT_DIR$/dev_environment/.unmanic/logs/*.log" show_all="true" />
     <module name="unmanic" />
     <option name="ENV_FILES" value="" />
     <option name="INTERPRETER_OPTIONS" value="" />
     <option name="PARENT_ENVS" value="true" />
     <envs>
-      <env name="HOME_DIR" value="./dev_environment" />
       <env name="PYTHONUNBUFFERED" value="1" />
+      <env name="HOME_DIR" value="./dev_environment" />
     </envs>
     <option name="SDK_HOME" value="$PROJECT_DIR$/venv/bin/python" />
     <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
@@ -15,7 +16,7 @@
     <option name="ADD_SOURCE_ROOTS" value="true" />
     <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
     <option name="SCRIPT_NAME" value="unmanic" />
-    <option name="PARAMETERS" value="--dev --dev-local-api" />
+    <option name="PARAMETERS" value="--dev" />
     <option name="SHOW_COMMAND_LINE" value="false" />
     <option name="EMULATE_TERMINAL" value="false" />
     <option name="MODULE_MODE" value="true" />
diff --git a/.idea/unmanic.iml b/.idea/unmanic.iml
index f8c80a41..f381af1b 100644
--- a/.idea/unmanic.iml
+++ b/.idea/unmanic.iml
@@ -9,7 +9,7 @@
       <excludeFolder url="file://$MODULE_DIR$/unmanic/webserver/frontend/.quasar" />
       <excludeFolder url="file://$MODULE_DIR$/dist" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.12 (unmanic)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.10 (unmanic)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="TemplatesService">
diff --git a/requirements.txt b/requirements.txt
index c0304f46..70ec2a98 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,6 +8,7 @@ psutil~=6.0.0
 requests>=2.28.2
 requests_toolbelt>=0.9.1
 py-cpuinfo>=7.0.0
+JSON-log-formatter~=0.5.2
 
 # Optional requirements
 watchdog>=2.1.1
diff --git a/tests/support_/test_data/data_queues.py b/tests/support_/test_data/data_queues.py
index 38db717e..eddd4995 100644
--- a/tests/support_/test_data/data_queues.py
+++ b/tests/support_/test_data/data_queues.py
@@ -31,14 +31,8 @@
 """
 import queue
 
-from unmanic.libs import unlogger
-
-unmanic_logging = unlogger.UnmanicLogger.__call__(False)
-unmanic_logging.get_logger()
-
 data_queues = {
     "scheduledtasks":   queue.Queue(),
     "inotifytasks":     queue.Queue(),
     "progress_reports": queue.Queue(),
-    "logging":          unmanic_logging
 }
diff --git a/tests/unit/test_unlogger.py b/tests/unit/test_unlogger.py
deleted file mode 100644
index 08005824..00000000
--- a/tests/unit/test_unlogger.py
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-    unmanic.test_unlogger.py
- 
-    Written by:               Josh.5 <jsunnex@gmail.com>
-    Date:                     08 Sep 2019, (8:45 AM)
- 
-    Copyright:
-           Copyright (C) Josh Sunnex - All Rights Reserved
- 
-           Permission is hereby granted, free of charge, to any person obtaining a copy
-           of this software and associated documentation files (the "Software"), to deal
-           in the Software without restriction, including without limitation the rights
-           to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-           copies of the Software, and to permit persons to whom the Software is
-           furnished to do so, subject to the following conditions:
-  
-           The above copyright notice and this permission notice shall be included in all
-           copies or substantial portions of the Software.
-  
-           THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-           EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-           MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-           IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-           DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-           OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
-           OR OTHER DEALINGS IN THE SOFTWARE.
-
-"""
-
-import os
-import sys
-
-import pytest
-
-try:
-    from unmanic.libs import unlogger
-except ImportError:
-    project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    sys.path.append(project_dir)
-    from unmanic.libs import unlogger
-
-
-class SettingsObject(object):
-    pass
-
-
-
-# TODO: Re-enable unit test once config object can be called without a DB connection
-class TestClass(object):
-    """
-    TestClass
-
-    Runs unit tests against the unlogger class
-
-    """
-
-    def setup_class(self):
-        """
-        Setup the class state for pytest
-        :return:
-        """
-        # Logging file handler is disabled for unit tests
-        unmanic_logging = unlogger.UnmanicLogger.__call__(False)
-        unmanic_logging.get_logger()
-
-    @pytest.mark.unittest
-    def test_logging_special_characters(self):
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        main_logger = unmanic_logging.get_logger()
-        main_logger.info("Check that these characters display correctly")
-        main_logger.info("Success: \u251c – € ’ “ ” « » — à á ã ç ê é í ó õ ú")
-        main_logger.info("Fails: \udce2\udc80\udc98")
diff --git a/unmanic/config.py b/unmanic/config.py
index 0907254d..91f61f39 100644
--- a/unmanic/config.py
+++ b/unmanic/config.py
@@ -34,8 +34,8 @@
 import json
 
 from unmanic import metadata
-from unmanic.libs import unlogger
 from unmanic.libs import common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.singleton import SingletonType
 
 try:
@@ -43,6 +43,8 @@
 except ImportError:
     JSONDecodeError = ValueError
 
+logger = UnmanicLogging.get_logger(name="Config")
+
 
 class Config(object, metaclass=SingletonType):
     app_version = ''
@@ -117,23 +119,6 @@ def __init__(self, config_path=None, **kwargs):
         # Apply settings to the unmanic logger
         self.__setup_unmanic_logger()
 
-    def _log(self, message, message2='', level="info"):
-        """
-        Generic logging method. Can be implemented on any unmanic class
-
-        :param message:
-        :param message2:
-        :param level:
-        :return:
-        """
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        logger = unmanic_logging.get_logger(__class__.__name__)
-        if logger:
-            message = common.format_message(message, message2)
-            getattr(logger, level)(message)
-        else:
-            print("Unmanic.{} - ERROR!!! Failed to find logger".format(self.__name__))
-
     def get_config_as_dict(self):
         """
         Return a dictionary of configuration fields and their current values
@@ -156,8 +141,7 @@ def __setup_unmanic_logger(self):
 
         :return:
         """
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        unmanic_logging.setup_logger(self)
+        UnmanicLogging.get_logger(settings=self)
 
     def __import_settings_from_env(self):
         """
@@ -189,7 +173,7 @@ def __import_settings_from_file(self, config_path=None):
                 with open(settings_file) as infile:
                     data = json.load(infile)
             except Exception as e:
-                self._log("Exception in reading saved settings from file:", message2=str(e), level="exception")
+                logger.exception("Exception in reading saved settings from file: %s", e)
             # Set data to Config class
             self.set_bulk_config_items(data, save_settings=False)
 
@@ -206,7 +190,7 @@ def __write_settings_to_file(self):
         result = common.json_dump_to_file(data, settings_file)
         if not result['success']:
             for message in result['errors']:
-                self._log("Error:", message2=str(message), level="error")
+                logger.error(message)
             raise Exception("Exception in writing settings to file")
 
     def get_config_item(self, key):
@@ -239,7 +223,7 @@ def set_config_item(self, key, value, save_settings=True):
         field_id = key.lower()
         # Check if key is a valid setting
         if field_id not in self.get_config_keys():
-            self._log("Attempting to save unknown key", message2=str(key), level="warning")
+            logger.warning("Attempting to save unknown key: %s", key)
             # Do not proceed if this is any key other than the database
             return
 
@@ -257,7 +241,7 @@ def set_config_item(self, key, value, save_settings=True):
             try:
                 self.__write_settings_to_file()
             except Exception as e:
-                self._log("Failed to write settings to file: ", message2=str(self.get_config_as_dict()), level="exception")
+                logger.exception("Failed to write settings to file: %s", str(self.get_config_as_dict()))
 
     def set_bulk_config_items(self, items, save_settings=True):
         """
@@ -323,7 +307,7 @@ def set_cache_path(self, cache_path):
         :return:
         """
         if cache_path == "":
-            self._log("Cache path cannot be empty. Resetting it to default", level="warning")
+            logger.warning("Cache path cannot be empty. Resetting it to default.")
             cache_path = common.get_default_cache_path()
         self.cache_path = cache_path
 
@@ -351,11 +335,10 @@ def set_debugging(self, value):
 
         :return:
         """
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
         if value:
-            unmanic_logging.enable_debugging()
+            UnmanicLogging.enable_debugging()
         else:
-            unmanic_logging.disable_debugging()
+            UnmanicLogging.disable_debugging()
         self.debugging = value
 
     def get_first_run(self):
diff --git a/unmanic/libs/__init__.py b/unmanic/libs/__init__.py
index c4eb6c41..f1e03bce 100644
--- a/unmanic/libs/__init__.py
+++ b/unmanic/libs/__init__.py
@@ -29,11 +29,3 @@
            OR OTHER DEALINGS IN THE SOFTWARE.
 
 """
-import sys
-import warnings
-
-from .unlogger import UnmanicLogger
-
-__all__ = (
-    'UnmanicLogger',
-)
diff --git a/unmanic/libs/db_migrate.py b/unmanic/libs/db_migrate.py
index 0ffd6a4d..40bd9f31 100644
--- a/unmanic/libs/db_migrate.py
+++ b/unmanic/libs/db_migrate.py
@@ -37,7 +37,7 @@
 from peewee import Model, SqliteDatabase, Field
 from peewee_migrate import Migrator, Router
 
-from unmanic.libs import unlogger
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.unmodels.lib import BaseModel
 
 
@@ -48,12 +48,10 @@ class Migrations(object):
     Handle all migrations during application start.
     """
 
-    logger = None
     database = None
 
     def __init__(self, config):
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
         # Based on configuration, select database to connect to.
         if config['TYPE'] == 'SQLITE':
@@ -70,12 +68,6 @@ def __init__(self, config):
 
             self.migrator = Migrator(self.database)
 
-    def __log(self, message, level='info'):
-        if self.logger:
-            getattr(self.logger, level)(message)
-        else:
-            print(message)
-
     def __run_all_migrations(self):
         """
         Run all new migrations.
@@ -102,7 +94,7 @@ def update_schema(self):
         all_models = [tup[1] for tup in discovered_models]
 
         # Start by creating all models
-        self.__log("Initialising database tables")
+        self.logger.info("Initialising database tables")
         try:
             with self.database.transaction():
                 for model in all_models:
@@ -110,7 +102,7 @@ def update_schema(self):
                 self.migrator.run()
         except Exception:
             self.database.rollback()
-            self.__log("Initialising tables failed", level='exception')
+            self.logger.exception("Initialising tables failed")
             raise
 
         # Migrations will only be used for removing obsolete columns
@@ -118,7 +110,7 @@ def update_schema(self):
 
         # Newly added fields can be auto added with this function... no need for a migration script
         # Ensure all files are also present for each of the model classes
-        self.__log("Updating database fields")
+        self.logger.info("Updating database fields")
         for model in all_models:
             if issubclass(model, BaseModel):
                 # Fetch all peewee fields for the model class
@@ -131,12 +123,12 @@ def update_schema(self):
                     if isinstance(field, Field):
                         if not any(f for f in self.database.get_columns(model._meta.name) if f.name == field.name):
                             # Field does not exist in DB table
-                            self.__log("Adding missing column")
+                            self.logger.info("Adding missing column")
                             try:
                                 with self.database.transaction():
                                     self.migrator.add_columns(model, **{field.name: field})
                                     self.migrator.run()
                             except Exception:
                                 self.database.rollback()
-                                self.__log("Update failed", level='exception')
+                                self.logger.exception("Update failed")
                                 raise
diff --git a/unmanic/libs/eventmonitor.py b/unmanic/libs/eventmonitor.py
index 703159ec..3efa57d5 100644
--- a/unmanic/libs/eventmonitor.py
+++ b/unmanic/libs/eventmonitor.py
@@ -36,6 +36,7 @@
 
 from unmanic import config
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.plugins import PluginsHandler
 
 try:
@@ -54,7 +55,6 @@ class FileSystemEventHandler(object):
 
     event_monitor_module = None
 
-from unmanic.libs import common, unlogger
 from unmanic.libs.filetest import FileTest
 
 
@@ -78,27 +78,20 @@ class EventHandler(FileSystemEventHandler):
     """
 
     def __init__(self, files_to_test, library_id):
-        self.name = "EventProcessor"
+        self.name = __class__.__name__
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.files_to_test = files_to_test
         self.library_id = library_id
-        self.logger = None
         self.abort_flag = threading.Event()
         self.abort_flag.clear()
 
-    def _log(self, message, message2='', level="info"):
-        if not self.logger:
-            unmanic_logging = unlogger.UnmanicLogger.__call__()
-            self.logger = unmanic_logging.get_logger(self.name)
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def on_any_event(self, event):
         if event.event_type in ["created", "closed"]:
             # Ensure event was not for a directory
             if event.is_directory:
-                self._log("Detected event is for a directory. Ignoring...", level="debug")
+                self.logger.debug("Detected event is for a directory. Ignoring...")
             else:
-                self._log("Detected '{}' event on file path '{}'".format(event.event_type, event.src_path))
+                self.logger.info("Detected '%s' event on file path '%s'", event.event_type, event.src_path)
                 self.files_to_test.put({
                     'src_path':   event.src_path,
                     'library_id': self.library_id,
@@ -117,10 +110,10 @@ class will stop or start the EventProcessor thread accordingly.
 
     def __init__(self, data_queues, event):
         super(EventMonitorManager, self).__init__(name='EventMonitorManager')
-        self.name = "EventMonitorManager"
+        self.name = __class__.__name__
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.data_queues = data_queues
         self.settings = config.Config()
-        self.logger = None
         self.event = event
 
         # Create an event queue
@@ -132,18 +125,11 @@ def __init__(self, data_queues, event):
         self.event_observer_thread = None
         self.event_observer_threads = []
 
-    def _log(self, message, message2='', level="info"):
-        if not self.logger:
-            unmanic_logging = unlogger.UnmanicLogger.__call__()
-            self.logger = unmanic_logging.get_logger(self.name)
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def stop(self):
         self.abort_flag.set()
 
     def run(self):
-        self._log("Starting EventMonitorManager loop")
+        self.logger.info("Starting EventMonitorManager loop")
         while not self.abort_flag.is_set():
             self.event.wait(.5)
 
@@ -164,7 +150,7 @@ def run(self):
                 try:
                     library = Library(lib_info['id'])
                 except Exception as e:
-                    self._log("Unable to fetch library config for ID {}".format(lib_info['id']), level='exception')
+                    self.logger.exception("Unable to fetch library config for ID %s", lib_info['id'])
                     continue
                 # Check if the library is configured for remote files only
                 if library.get_enable_remote_only():
@@ -187,7 +173,7 @@ def run(self):
             self.event.wait(2)
 
         self.stop_event_processor()
-        self._log("Leaving EventMonitorManager loop...")
+        self.logger.info("Leaving EventMonitorManager loop...")
 
     def system_configuration_is_valid(self):
         """
@@ -217,7 +203,7 @@ def start_event_processor(self):
                 try:
                     library = Library(lib_info['id'])
                 except Exception as e:
-                    self._log("Unable to fetch library config for ID {}".format(lib_info['id']), level='exception')
+                    self.logger.exception("Unable to fetch library config for ID %s", lib_info['id'])
                     continue
                 # Check if the library is configured for remote files only
                 if library.get_enable_remote_only():
@@ -228,16 +214,16 @@ def start_event_processor(self):
                     library_path = library.get_path()
                     if not os.path.exists(library_path):
                         continue
-                    self._log("Adding library path to monitor '{}'".format(library_path))
+                    self.logger.info("Adding library path to monitor '%s'", library_path)
                     event_handler = EventHandler(self.files_to_test, library.get_id())
                     self.event_observer_thread.schedule(event_handler, library_path, recursive=True)
                     monitoring_path = True
             # Only start observer if a path was added to be monitored
             if monitoring_path:
-                self._log("EventMonitorManager spawning EventProcessor thread...")
+                self.logger.info("EventMonitorManager spawning EventProcessor thread...")
                 self.event_observer_thread.start()
         else:
-            self._log("Given signal to start the EventProcessor thread, but it is already running....")
+            self.logger.info("Given signal to start the EventProcessor thread, but it is already running....")
 
     def stop_event_processor(self):
         """
@@ -246,16 +232,16 @@ def stop_event_processor(self):
         :return:
         """
         if self.event_observer_thread:
-            self._log("EventMonitorManager stopping EventProcessor thread...")
+            self.logger.info("EventMonitorManager stopping EventProcessor thread...")
 
-            self._log("Sending thread EventProcessor abort signal")
+            self.logger.info("Sending thread EventProcessor abort signal")
             self.event_observer_thread.stop()
 
-            self._log("Waiting for thread EventProcessor to stop")
+            self.logger.info("Waiting for thread EventProcessor to stop")
             self.event_observer_thread.join()
-            self._log("Thread EventProcessor has successfully stopped")
+            self.logger.info("Thread EventProcessor has successfully stopped")
         else:
-            self._log("Given signal to stop the EventProcessor thread, but it is not running...")
+            self.logger.info("Given signal to stop the EventProcessor thread, but it is not running...")
 
         self.event_observer_thread = None
 
@@ -277,16 +263,16 @@ def manage_event_queue(self, pathname, library_id):
             # Log any error messages
             for issue in issues:
                 if type(issue) is dict:
-                    self._log(issue.get('message'))
+                    self.logger.info(issue.get('message'))
                 else:
-                    self._log(issue)
+                    self.logger.info(issue)
             # If file needs to be added, then add it
             if result:
                 self.__add_path_to_queue(pathname, library_id, priority_score)
         except UnicodeEncodeError:
-            self._log("File contains Unicode characters that cannot be processed. Ignoring.", level="warning")
+            self.logger.warning("File contains Unicode characters that cannot be processed. Ignoring.")
         except Exception as e:
-            self._log("Exception testing file path in {}. Ignoring.".format(self.name), message2=str(e), level="exception")
+            self.logger.exception("Exception testing file path in %s. Ignoring.", self.name)
 
     def __add_path_to_queue(self, pathname, library_id, priority_score):
         """
diff --git a/unmanic/libs/filetest.py b/unmanic/libs/filetest.py
index da588427..526a1f28 100644
--- a/unmanic/libs/filetest.py
+++ b/unmanic/libs/filetest.py
@@ -36,7 +36,8 @@
 from copy import deepcopy
 
 from unmanic import config
-from unmanic.libs import history, common, unlogger
+from unmanic.libs import history, common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.plugins import PluginsHandler
 
 
@@ -51,8 +52,7 @@ class FileTest(object):
 
     def __init__(self, library_id: int):
         self.settings = config.Config()
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
         # Init plugins
         self.library_id = library_id
@@ -63,10 +63,6 @@ def __init__(self, library_id: int):
         # List of filed tasks
         self.failed_paths = []
 
-    def _log(self, message, message2='', level="info"):
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def set_file(self):
         pass
 
@@ -172,7 +168,7 @@ class FileTesterThread(threading.Thread):
     def __init__(self, name, files_to_test, files_to_process, status_updates, library_id, event):
         super(FileTesterThread, self).__init__(name=name)
         self.settings = config.Config()
-        self.logger = None
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.event = event
         self.files_to_test = files_to_test
         self.files_to_process = files_to_process
@@ -181,18 +177,11 @@ def __init__(self, name, files_to_test, files_to_process, status_updates, librar
         self.abort_flag = threading.Event()
         self.abort_flag.clear()
 
-    def _log(self, message, message2='', level="info"):
-        if not self.logger:
-            unmanic_logging = unlogger.UnmanicLogger.__call__()
-            self.logger = unmanic_logging.get_logger(self.name)
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def stop(self):
         self.abort_flag.set()
 
     def run(self):
-        self._log("Starting {}".format(self.name))
+        self.logger.info("Starting %s", self.name)
         file_test = FileTest(self.library_id)
         while not self.abort_flag.is_set():
             try:
@@ -203,8 +192,8 @@ def run(self):
                 self.event.wait(2)
                 continue
             except Exception as e:
-                self._log("Exception in fetching library scan result for path {}:".format(self.name), message2=str(e),
-                            level="exception")
+                self.logger.exception("Exception in fetching library scan result for path %s:", self.name)
+                continue
 
             # Test file to be added to task list. Add it if required
             try:
@@ -212,9 +201,9 @@ def run(self):
                 # Log any error messages
                 for issue in issues:
                     if type(issue) is dict:
-                        self._log(issue.get('message'))
+                        self.logger.info(issue.get('message'))
                     else:
-                        self._log(issue)
+                        self.logger.info(issue)
                 # If file needs to be added, then add it
                 if result:
                     self.add_path_to_queue({
@@ -222,12 +211,11 @@ def run(self):
                         'priority_score': priority_score,
                     })
             except UnicodeEncodeError:
-                self._log("File contains Unicode characters that cannot be processed. Ignoring.", level="warning")
+                self.logger.warning("File contains Unicode characters that cannot be processed. Ignoring.")
             except Exception as e:
-                self._log("Exception testing file path in {}. Ignoring.".format(self.name), message2=str(e),
-                            level="exception")
+                self.logger.exception("Exception testing file path in %s. Ignoring.", self.name)
 
-        self._log("Exiting {}".format(self.name))
+        self.logger.info("Exiting %s", self.name)
 
     def add_path_to_queue(self, item):
         self.files_to_process.put(item)
diff --git a/unmanic/libs/foreman.py b/unmanic/libs/foreman.py
index 1177d13e..c4bf61c0 100644
--- a/unmanic/libs/foreman.py
+++ b/unmanic/libs/foreman.py
@@ -38,6 +38,7 @@
 
 from unmanic.libs import common, installation_link
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.plugins import PluginsHandler
 from unmanic.libs.worker_group import WorkerGroup
 from unmanic.libs.workers import Worker
@@ -50,7 +51,7 @@ def __init__(self, data_queues, settings, task_queue, event):
         self.event = event
         self.task_queue = task_queue
         self.data_queues = data_queues
-        self.logger = data_queues["logging"].get_logger(self.name)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.workers_pending_task_queue = queue.Queue(maxsize=1)
         self.remote_workers_pending_task_queue = queue.Queue(maxsize=1)
         self.complete_queue = queue.Queue()
diff --git a/unmanic/libs/history.py b/unmanic/libs/history.py
index 8b40832c..76cb7cd1 100644
--- a/unmanic/libs/history.py
+++ b/unmanic/libs/history.py
@@ -35,7 +35,8 @@
 from operator import attrgetter
 
 from unmanic import config
-from unmanic.libs import common, unlogger
+from unmanic.libs import common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.unmodels import CompletedTasks, CompletedTasksCommandLogs
 
 try:
@@ -52,17 +53,9 @@ class History(object):
     """
 
     def __init__(self):
-        self.name = 'History'
+        self.name = __class__.__name__
         self.settings = config.Config()
-
-    def _log(self, message, message2='', level="info"):
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        logger = unmanic_logging.get_logger(self.name)
-        if logger:
-            message = common.format_message(message, message2)
-            getattr(logger, level)(message)
-        else:
-            print("Unmanic.{} - ERROR!!! Failed to find logger".format(self.name))
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def get_historic_task_list(self, limit=None):
         """
@@ -78,7 +71,7 @@ def get_historic_task_list(self, limit=None):
                 historic_tasks = CompletedTasks.select().order_by(CompletedTasks.id.desc())
         except CompletedTasks.DoesNotExist:
             # No historic entries exist yet
-            self._log("No historic tasks exist yet.", level="warning")
+            self.logger.warning("No historic tasks exist yet.")
             historic_tasks = []
 
         return historic_tasks.dicts()
@@ -121,7 +114,7 @@ def get_historic_task_list_filtered_and_sorted(self, order=None, start=0, length
 
         except CompletedTasks.DoesNotExist:
             # No historic entries exist yet
-            self._log("No historic tasks exist yet.", level="warning")
+            self.logger.warning("No historic tasks exist yet.")
             query = []
 
         return query.dicts()
@@ -129,12 +122,13 @@ def get_historic_task_list_filtered_and_sorted(self, order=None, start=0, length
     def get_current_path_of_historic_tasks_by_id(self, id_list=None):
         """
         Returns a list of CompletedTasks filtered by id_list and joined with the current absolute path of that file.
-        For failures this will be the the source path
+        For failures this will be the source path
         For success, this will be the destination path
 
         :param id_list:
         :return:
         """
+        # noinspection SqlDialectInspection
         """
             SELECT
                 t1.*,
@@ -196,7 +190,7 @@ def get_historic_task_data_dictionary(self, task_id):
             # Fetch the historic task (get() will raise DoesNotExist exception if no results are found)
             historic_tasks = CompletedTasks.get_by_id(task_id)
         except CompletedTasks.DoesNotExist:
-            self._log("Failed to retrieve historic task from database for id {}.".format(task_id), level="exception")
+            self.logger.exception("Failed to retrieve historic task from database for id %s.", task_id)
             return False
         # Get all saved data for this task and create dictionary of task data
         historic_task = historic_tasks.model_to_dict()
@@ -225,15 +219,14 @@ def delete_historic_tasks_recursively(self, id_list=None):
                     historic_task_id.delete_instance(recursive=True)
                 except Exception as e:
                     # Catch delete exceptions
-                    self._log("An error occurred while deleting historic task ID: {}.".format(historic_task_id), str(e),
-                              level="exception")
+                    self.logger.exception("An error occurred while deleting historic task ID: %s.", historic_task_id)
                     return False
 
             return True
 
         except CompletedTasks.DoesNotExist:
             # No historic entries exist yet
-            self._log("No historic tasks exist yet.", level="warning")
+            self.logger.warning("No historic tasks exist yet.")
 
     def save_task_history(self, task_data):
         """
@@ -248,7 +241,7 @@ def save_task_history(self, task_data):
             # Create an entry of the data from the source ffprobe
             self.create_historic_task_ffmpeg_log_entry(new_historic_task, task_data.get('log', ''))
         except Exception as error:
-            self._log("Failed to save historic task entry to database.", str(error), level="exception")
+            self.logger.exception("Failed to save historic task entry to database. %s", error)
             return False
         return True
 
@@ -281,7 +274,7 @@ def create_historic_task_entry(self, task_data):
         :return:
         """
         if not task_data:
-            self._log('Task data param empty', json.dumps(task_data), level="debug")
+            self.logger.debug('Task data param empty: %s', json.dumps(task_data))
             raise Exception('Task data param empty. This should not happen - Something has gone really wrong.')
 
         new_historic_task = CompletedTasks.create(task_label=task_data['task_label'],
diff --git a/unmanic/libs/installation_link.py b/unmanic/libs/installation_link.py
index 6988757e..3d7571a7 100644
--- a/unmanic/libs/installation_link.py
+++ b/unmanic/libs/installation_link.py
@@ -40,8 +40,9 @@
 from requests_toolbelt import MultipartEncoder
 
 from unmanic import config
-from unmanic.libs import common, session, task, unlogger
+from unmanic.libs import common, session, task
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.session import Session
 from unmanic.libs.singleton import SingletonType
 
@@ -81,8 +82,7 @@ class Links(object, metaclass=SingletonType):
     def __init__(self, *args, **kwargs):
         self.settings = config.Config()
         self.session = session.Session()
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def _log(self, message, message2='', level="info"):
         message = common.format_message(message, message2)
@@ -1208,8 +1208,7 @@ def __init__(self, thread_id, name, installation_info, pending_queue, complete_q
         self.paused_flag.clear()
 
         # Create logger for this worker
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(self.name)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def _log(self, message, message2='', level="info"):
         message = common.format_message(message, message2)
diff --git a/unmanic/libs/libraryscanner.py b/unmanic/libs/libraryscanner.py
index 8860f707..7a58a03f 100644
--- a/unmanic/libs/libraryscanner.py
+++ b/unmanic/libs/libraryscanner.py
@@ -36,24 +36,23 @@
 import threading
 import time
 
-import psutil
 import schedule
 
 from unmanic import config
-from unmanic.libs import common, unlogger
 from unmanic.libs.filetest import FileTesterThread
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.plugins import PluginsHandler
 
 
 class LibraryScannerManager(threading.Thread):
     def __init__(self, data_queues, event):
         super(LibraryScannerManager, self).__init__(name='LibraryScannerManager')
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.interval = 0
         self.firstrun = True
         self.data_queues = data_queues
         self.settings = config.Config()
-        self.logger = None
         self.event = event
         self.scheduledtasks = data_queues["scheduledtasks"]
         self.library_scanner_triggers = data_queues["library_scanner_triggers"]
@@ -65,13 +64,6 @@ def __init__(self, data_queues, event):
         self.files_to_test = queue.Queue()
         self.files_to_process = queue.Queue()
 
-    def _log(self, message, message2='', level="info"):
-        if not self.logger:
-            unmanic_logging = unlogger.UnmanicLogger.__call__()
-            self.logger = unmanic_logging.get_logger(self.name)
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def stop(self):
         self.abort_flag.set()
         # Stop all child threads
@@ -88,7 +80,7 @@ def abort_is_set(self):
         return False
 
     def run(self):
-        self._log("Starting LibraryScanner Monitor loop")
+        self.logger.info("Starting LibraryScanner Monitor loop")
         while not self.abort_is_set():
             self.event.wait(1)
 
@@ -96,7 +88,7 @@ def run(self):
             if int(self.settings.get_schedule_full_scan_minutes()) != self.interval:
                 self.interval = int(self.settings.get_schedule_full_scan_minutes())
             if self.interval and self.interval != 0:
-                self._log("Setting LibraryScanner schedule to scan every {} mins...".format(self.interval))
+                self.logger.info("Setting LibraryScanner schedule to scan every %s mins...", self.interval)
                 # Configure schedule
                 self.scheduler.every(self.interval).minutes.do(self.scheduled_job)
                 # Register application
@@ -104,7 +96,7 @@ def run(self):
 
                 # First run the task
                 if self.settings.get_run_full_scan_on_start() and self.firstrun:
-                    self._log("Running LibraryScanner on start")
+                    self.logger.info("Running LibraryScanner on start")
                     self.scheduled_job()
                 self.firstrun = False
 
@@ -123,8 +115,7 @@ def run(self):
                     except queue.Empty:
                         continue
                     except Exception as e:
-                        self._log("Exception in retrieving library scanner trigger {}:".format(self.name), message2=str(e),
-                                  level="exception")
+                        self.logger.exception("Exception in retrieving library scanner trigger %s: %s", self.name, e)
 
                     # Check if library scanner is enabled
                     if not self.settings.get_enable_library_scanner():
@@ -137,11 +128,11 @@ def run(self):
                     # If the settings have changed, then break this loop and clear
                     # the scheduled job resetting to the new interval
                     if int(self.settings.get_schedule_full_scan_minutes()) != self.interval:
-                        self._log("Resetting LibraryScanner schedule")
+                        self.logger.info("Resetting LibraryScanner schedule")
                         break
                 self.scheduler.clear()
 
-        self._log("Leaving LibraryScanner Monitor loop...")
+        self.logger.info("Leaving LibraryScanner Monitor loop...")
 
     def scheduled_job(self):
         """
@@ -150,7 +141,7 @@ def scheduled_job(self):
         :return:
         """
         if not self.system_configuration_is_valid():
-            self._log("Skipping library scanner due invalid system configuration.", level='warning')
+            self.logger.warning("Skipping library scanner due invalid system configuration.")
             return
 
         # For each configured library, check if a library scan is required
@@ -160,7 +151,7 @@ def scheduled_job(self):
             try:
                 library = Library(lib_info['id'])
             except Exception as e:
-                self._log("Unable to fetch library config for ID {}".format(lib_info['id']), level='exception')
+                self.logger.exception("Unable to fetch library config for ID %s", lib_info['id'])
                 continue
             # Check if the library is configured for remote files only
             if library.get_enable_remote_only():
@@ -169,10 +160,10 @@ def scheduled_job(self):
             # Check if library scanner is enabled on any library
             if library.get_enable_scanner():
                 # Run library scan
-                self._log("Running full library scan on library '{}'".format(library.get_name()))
+                self.logger.info("Running full library scan on library '%s'", library.get_name())
                 self.scan_library_path(library.get_path(), library.get_id())
         if no_libraries_configured:
-            self._log("No libraries are configured to run a library scan")
+            self.logger.info("No libraries are configured to run a library scan")
 
     def system_configuration_is_valid(self):
         """
@@ -215,10 +206,10 @@ def scan_library_path(self, library_path, library_id):
         :return:
         """
         if not os.path.exists(library_path):
-            self._log("Path does not exist - '{}'".format(library_path), level="warning")
+            self.logger.warning("Path does not exist - '%s'", library_path)
             return
         if self.settings.get_debugging():
-            self._log("Scanning directory - '{}'".format(library_path), level="debug")
+            self.logger.debug("Scanning directory - '%s'", library_path)
 
         # Push status notification to frontend
         frontend_messages = self.data_queues.get('frontend_messages')
@@ -250,7 +241,7 @@ def scan_library_path(self, library_path, library_id):
             if self.abort_flag.is_set():
                 break
             if self.settings.get_debugging():
-                self._log(json.dumps(files, indent=2), level="debug")
+                self.logger.debug(json.dumps(files, indent=2))
             # Add all files in this path that match our container filter
             for file_path in files:
                 if self.abort_flag.is_set():
@@ -326,7 +317,7 @@ def scan_library_path(self, library_path, library_id):
             self.file_test_managers[manager_id].abort_flag.set()
             self.file_test_managers[manager_id].join(2)
 
-        self._log("Library scan completed in {} seconds".format((time.time() - start_time)), level="warning")
+        self.logger.warning("Library scan completed in %s seconds", str((time.time() - start_time)))
 
         # Run a manual garbage collection
         gc.collect()
diff --git a/unmanic/libs/logs.py b/unmanic/libs/logs.py
new file mode 100644
index 00000000..929e3ae9
--- /dev/null
+++ b/unmanic/libs/logs.py
@@ -0,0 +1,550 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+    unmanic.unlogger.py
+
+    Written by:               Josh.5 <jsunnex@gmail.com>
+    Date:                     06 Jan 2019, (8:41 AM)
+
+    Copyright:
+           Copyright (C) Josh Sunnex - All Rights Reserved
+
+           Permission is hereby granted, free of charge, to any person obtaining a copy
+           of this software and associated documentation files (the "Software"), to deal
+           in the Software without restriction, including without limitation the rights
+           to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+           copies of the Software, and to permit persons to whom the Software is
+           furnished to do so, subject to the following conditions:
+
+           The above copyright notice and this permission notice shall be included in all
+           copies or substantial portions of the Software.
+
+           THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+           EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+           MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+           IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+           DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+           OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+           OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+
+import os
+import logging
+import threading
+import json
+import time
+from logging.handlers import RotatingFileHandler
+from queue import Queue, Empty
+import requests
+from datetime import datetime, timedelta
+from json_log_formatter import JSONFormatter
+
+
+class ForwardJSONFormatter(JSONFormatter):
+    """
+    JSON log formatter which adds log record attributes if debugging is enabled.
+    """
+
+    def json_record(self, message, extra, record):
+        # Check the logger's effective level
+        logger = logging.getLogger(record.name)
+        # Always include levelname used for labels
+        extra['levelname'] = record.levelname
+        # If the logger's effective level is DEBUG, add more context
+        if logger.getEffectiveLevel() == logging.DEBUG:
+            extra['filename'] = record.filename
+            extra['funcName'] = record.funcName
+            extra['lineno'] = record.lineno
+            extra['module'] = record.module
+            extra['name'] = record.name
+            extra['pathname'] = record.pathname
+            extra['process'] = record.process
+            extra['processName'] = record.processName
+            if hasattr(record, 'stack_info'):
+                extra['stack_info'] = record.stack_info
+            else:
+                extra['stack_info'] = None
+            extra['thread'] = record.thread
+            extra['threadName'] = record.threadName
+        return super(ForwardJSONFormatter, self).json_record(message, extra, record)
+
+
+class ForwardLogHandler(logging.Handler):
+    """
+    A custom log handler that:
+    - Writes incoming logs to disk in chunk files at intervals or size thresholds.
+    - A separate thread reads these chunk files from disk and forwards them.
+    - On success, chunk files are removed.
+    - On failure, chunk files remain for later retry.
+    """
+
+    def __init__(self, endpoint, buffer_path, app_id, labels=None, flush_interval=5, max_chunk_size=5 * 1024 * 1024):
+        # TODO: Set default flush interval to 10 seconds
+        super().__init__()
+        self.endpoint = endpoint
+        self.buffer_path = buffer_path
+        self.app_id = app_id
+        self.labels = labels if labels is not None else {"job": "unmanic"}
+        self.flush_interval = flush_interval
+        self.max_chunk_size = max_chunk_size
+
+        self.log_queue = Queue()
+        self.stop_event = threading.Event()
+
+        # Thread that processes logs from the queue and writes them to disk
+        self.writer_thread = threading.Thread(target=self._process_logs, daemon=True)
+        self.writer_thread.start()
+
+        # Thread that periodically attempts to send logs from disk
+        self.sender_thread = threading.Thread(target=self._send_from_disk, daemon=True)
+        self.sender_thread.start()
+
+    def emit(self, record):
+        try:
+            log_entry = self.format(record)
+
+            # Set log timestamp in nanoseconds
+            ts = str(int(time.time() * 1e9))
+            if hasattr(record, 'created'):
+                ts = str(int(record.created * 1e9))
+
+            # Set default labels
+            labels = {
+                "job":      "unmanic",
+                "logger":   record.name,
+                "level":    record.levelname,
+                "log_type": "APPLICATION_LOG",
+            }
+
+            # If the record has a log_type attribute, override
+            if hasattr(record, 'log_type') and record.log_type:
+                labels['log_type'] = record.log_type
+
+            self.log_queue.put({
+                "labels": labels,
+                "entry":  [ts, log_entry]
+            })
+        except Exception as e:
+            logging.getLogger("Unmanic.ForwardLogHandler").error("Failed to enqueue log: %s", e)
+
+    def _process_logs(self):
+        """
+        Reads logs from the queue and writes them to disk in chunks.
+        Chunks are created either at flush_interval timeout or if max_chunk_size is reached.
+        """
+        buffer = []
+        buffer_size = 0
+        last_flush_time = time.time()
+
+        while not self.stop_event.is_set():
+
+            try:
+                log_entry = self.log_queue.get(timeout=0.2)
+                if log_entry is None:
+                    # Sentinel received, means shutdown is requested
+                    break
+                # Process the log entry
+                buffer.append(log_entry)
+                buffer_size += len(log_entry)
+
+                # If size exceeds max_chunk_size, flush now
+                if buffer_size >= self.max_chunk_size:
+                    self._flush_to_disk(buffer)
+                    buffer = []
+                    buffer_size = 0
+                    last_flush_time = time.time()
+
+            except Empty:
+                # No logs available right now
+                pass
+
+            current_time = time.time()
+            if current_time - last_flush_time >= 5:
+                # Flush to disk if more than 5 seconds have passed
+                if buffer:
+                    self._flush_to_disk(buffer)
+                    buffer = []
+                    buffer_size = 0
+                    last_flush_time = current_time
+
+        # Outside the loop, if we are shutting down and have pending logs, flush them
+        if buffer:
+            self._flush_to_disk(buffer)
+
+    def _flush_to_disk(self, buffer):
+        """
+        Write the given buffer of logs to a new chunk file on disk.
+        The file name includes a timestamp to ensure ordering by time.
+        """
+        try:
+            if not os.path.exists(self.buffer_path):
+                os.makedirs(self.buffer_path)
+
+            if not buffer:
+                # Nothing in buffer
+                return
+
+            timestamp_str = datetime.utcnow().isoformat()
+            buffer_file = os.path.join(self.buffer_path, f"log_buffer_{timestamp_str}.json.lock")
+
+            with open(buffer_file, "w") as f:
+                for log_entry in buffer:
+                    f.write(json.dumps(log_entry) + "\n")
+
+            # Rename the file to indicate it is ready for processing
+            os.rename(buffer_file, buffer_file.rstrip(".lock"))
+        except Exception as e:
+            logging.getLogger("Unmanic.ForwardLogHandler").error("Failed to save logs to disk: %s", e)
+
+    def _send_from_disk(self):
+        """
+        Periodically attempts to send logs from disk.
+        Processes one file at a time, oldest first.
+        If successful (204), deletes the file.
+        If failed, leaves the file for later retry.
+        """
+        while not self.stop_event.is_set():
+            # Attempt to send the oldest file first
+            buffer_files = self._get_buffer_files()
+            if not buffer_files:
+                # No files to send, sleep
+                self.stop_event.wait(timeout=10)
+                continue
+
+            for buffer_file in buffer_files:
+                if self._buffer_file_older_than_one_week(buffer_file):
+                    os.remove(buffer_file)
+                elif not self._attempt_send_file(buffer_file):
+                    # Add a longer pause here and then retry after the delay
+                    self.stop_event.wait(timeout=60)
+                self.stop_event.wait(timeout=0.2)
+            self.stop_event.wait(timeout=0.2)
+
+    def _get_buffer_files(self):
+        """
+        Returns a sorted list of buffer files based on their timestamp in the filename.
+        """
+        if not os.path.exists(self.buffer_path):
+            return []
+        files = [f for f in os.listdir(self.buffer_path) if f.startswith("log_buffer_") and f.endswith(".json")]
+        files.sort()
+        return [os.path.join(self.buffer_path, f) for f in files]
+
+    def _attempt_send_file(self, buffer_file):
+        """
+        Attempt to send the logs from buffer_file.
+        On success, delete the file.
+        On failure, leave it for next retry.
+        """
+        try:
+            buffer = []
+            with open(buffer_file, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        buffer.append(json.loads(line))
+
+            if not buffer:
+                # Empty file, just remove it
+                os.remove(buffer_file)
+                return True
+
+            payload = self._create_payload(buffer)
+            response = requests.post(self.endpoint, json=payload, headers={"Content-Type": "application/json"})
+
+            if response.status_code == 204:
+                # Success, remove the file
+                os.remove(buffer_file)
+                return True
+            else:
+                logging.getLogger("Unmanic.ForwardLogHandler").error("Failed to forward logs from %s to remote host %s: %s %s",
+                                                                     os.path.basename(buffer_file),
+                                                                     self.endpoint,
+                                                                     response.status_code,
+                                                                     response.text)
+                # Leave the file for later retry
+        except requests.exceptions.ConnectionError as e:
+            # Ignore this. We will try again later
+            logging.getLogger("Unmanic.ForwardLogHandler").warning(
+                "ConnectionError on remote endpoint %s. Ensure this URL is reachable by Unmanic.",
+                self.endpoint)
+        except Exception as e:
+            logging.getLogger("Unmanic.ForwardLogHandler").exception("Exception while trying to forward logs from %s: %s",
+                                                                     buffer_file, e)
+            # Leave the file for later retry
+        return False
+
+    @staticmethod
+    def _buffer_file_older_than_one_week(buffer_file):
+        """
+        Check if the log buffer file is older than one week based on its timestamp in the filename.
+
+        The expected filename format is:
+          log_buffer_YYYY-MM-DDTHH:MM:SS.ffffff.json
+
+        Returns True if the timestamp is older than one week, otherwise False.
+        """
+        basename = os.path.basename(buffer_file)
+        prefix = "log_buffer_"
+        suffix = ".json"
+
+        if not (basename.startswith(prefix) and basename.endswith(suffix)):
+            return False  # Filename doesn't match expected pattern.
+
+        # Extract the timestamp part from the filename.
+        timestamp_str = basename[len(prefix):-len(suffix)]
+
+        try:
+            file_timestamp = datetime.fromisoformat(timestamp_str)
+        except ValueError:
+            # Unable to parse the timestamp.
+            return False
+
+        one_week_ago = datetime.now() - timedelta(weeks=1)
+        return file_timestamp < one_week_ago
+
+    def _create_payload(self, buffer):
+        """
+        Create the payload from the given buffer of logs.
+        {
+          "streams": [
+            {
+              "stream": { "label": "value", ... },
+              "values": [
+                [ "<ts in ns>", "<log line>" ],
+                ...
+              ]
+            }
+          ]
+        }
+        """
+        combined_streams = {}
+        for log_item in buffer:
+            stream_key = frozenset(log_item["labels"].items())
+            if stream_key not in combined_streams:
+                combined_streams[stream_key] = {
+                    "stream": dict(log_item["labels"]),
+                    "values": []
+                }
+            combined_streams[stream_key]["values"].append(log_item["entry"])
+
+        return {
+            "app_id": self.app_id,
+            "data":   {"streams": list(combined_streams.values())}
+        }
+
+    def close(self):
+        """
+        Stop the log handler gracefully.
+        Ensures all logs in the queue are flushed to disk.
+        """
+        # Place Sentinel entry into queue to indicate that no more logs should be processed
+        self.log_queue.put(None)
+
+        # Signal the thread to stop
+        self.stop_event.set()
+
+        # Wait for the threads to finish processing
+        self.writer_thread.join()
+        self.sender_thread.join()
+
+        # Explicitly flush any remaining logs in the queue
+        remaining_logs = []
+        while True:
+            try:
+                log_entry = self.log_queue.get(timeout=1)
+                if log_entry is not None:
+                    remaining_logs.append(log_entry)
+            except Empty:
+                # No logs available right now, break loop
+                break
+
+        if remaining_logs:
+            self._flush_to_disk(remaining_logs)
+
+        super().close()
+
+
+class UnmanicLogging:
+    METRIC = 15
+    _instance = None
+    _lock = threading.Lock()
+    _configured = False
+    _log_path = None
+    stream_handler = None  # Stream handler
+    file_handler = None  # File handler
+    remote_handler = None  # Remote log handler
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(UnmanicLogging, cls).__new__(cls)
+                cls._instance._logger = logging.getLogger("Unmanic")
+                logging.addLevelName(cls._instance.METRIC, "METRIC")
+                cls._instance._logger.setLevel(logging.INFO)
+                cls._instance._logger.propagate = False
+            return cls._instance
+
+    @staticmethod
+    def get_logger(name=None, settings=None):
+        """
+        Get a child logger. Configure the root logger if 'settings' are provided.
+        """
+        logger_instance = UnmanicLogging()
+        if settings and not logger_instance._configured:
+            logger_instance.configure(settings)
+
+        if name:
+            return logging.getLogger(f"Unmanic.{name}")
+        return logger_instance._logger
+
+    def configure(self, settings):
+        """
+        Configure the logger using the provided Config settings instance.
+
+        :param settings: Instance of Config class with application settings.
+        """
+        with self._lock:
+            if self._configured:
+                return
+            # Get logger for this class
+            init_logger = logging.getLogger(f"Unmanic.UnmanicLogging")
+
+            # Default formatter
+            formatter = logging.Formatter(
+                '%(asctime)s:%(levelname)s:%(name)s - %(message)s',
+                datefmt='%Y-%m-%dT%H:%M:%S'
+            )
+
+            # Set up stream handler
+            if self.stream_handler is None:
+                self.stream_handler = logging.StreamHandler()
+                self.stream_handler.setFormatter(formatter)
+                # Set the log level of the stream handle for this log line only
+                self.stream_handler.setLevel(logging.INFO)
+                self._logger.addHandler(self.stream_handler)
+                # Add an info log to let users know where to look for their logs
+                init_logger.info("Initialising file logger. All further logs should output to the 'unmanic.log' file")
+                # Set the log level of the stream handle always to error
+                self.stream_handler.setLevel(logging.CRITICAL)
+
+            # Set up file handler if log path exists
+            self._log_path = settings.get_log_path()
+            if self._log_path:
+                if not os.path.exists(self._log_path):
+                    os.makedirs(self._log_path)
+
+                self.file_handler = RotatingFileHandler(
+                    os.path.join(self._log_path, "unmanic.log"), maxBytes=10 * 1024 * 1024, backupCount=5
+                )
+                self.file_handler.setFormatter(formatter)
+                # Set file handler log level based on debugging setting
+                self.file_handler.setLevel(logging.DEBUG if settings.get_debugging() else logging.INFO)
+                self._logger.addHandler(self.file_handler)
+
+            # Set root logger level
+            self._logger.setLevel(logging.DEBUG if settings.get_debugging() else logging.INFO)
+            self._configured = True
+
+    @staticmethod
+    def metric(name: str, timestamp: datetime = None, **kwargs):
+        """
+        Custom log method for the METRIC level.
+        Logs directly to the remote_handler, if enabled.
+        """
+        instance = UnmanicLogging()
+        # Metrics only go to the https handler
+        if instance.remote_handler:
+            if not timestamp:
+                timestamp = datetime.now()
+            log_record = {
+                'log_type':         'METRIC',
+                'metric_name':      name,
+                'metric_timestamp': f"{int(timestamp.timestamp())}.{timestamp.microsecond}",
+                **kwargs
+            }
+            log_message = " ".join(
+                f'{key}="{value}"' if " " in str(value) else f"{key}={value}"
+                for key, value in log_record.items() if value
+            )
+            instance._logger.log(instance.METRIC, log_message, extra=log_record)
+
+    @staticmethod
+    def enable_debugging():
+        """
+        Enable debugging globally across all threads.
+        """
+        instance = UnmanicLogging()
+        instance._logger.setLevel(logging.DEBUG)
+        instance._logger.info("Log level set to DEBUG")
+
+    @staticmethod
+    def disable_debugging():
+        """
+        Disable debugging globally across all threads.
+        """
+        instance = UnmanicLogging()
+        instance._logger.setLevel(logging.INFO)
+        instance._logger.info("Log level set to INFO")
+
+    @staticmethod
+    def disable_file_handler(debugging=False):
+        """
+        Disable logging to file and only log to stdout.
+
+        :param debugging: If True, sets stream handler to DEBUG level; otherwise INFO level.
+        """
+        instance = UnmanicLogging()
+
+        # Remove file handler if it exists
+        if instance.file_handler:
+            instance._logger.removeHandler(instance.file_handler)
+            instance.file_handler = None
+            instance._logger.info("File logging disabled. Logging only to stdout.")
+
+        # Adjust stream handler level
+        if instance.stream_handler:
+            instance.stream_handler.setLevel(logging.DEBUG if debugging else logging.INFO)
+            instance._logger.info(f"Stream logging set to {'DEBUG' if debugging else 'INFO'}")
+
+    @staticmethod
+    def update_stream_formatter(formatter):
+        """
+        Update the formatter of the stream handler.
+
+        :param formatter: A logging.Formatter instance.
+        """
+        instance = UnmanicLogging()
+        if instance.stream_handler:
+            instance.stream_handler.setFormatter(formatter)
+            instance._logger.info("Stream handler formatter updated.")
+        else:
+            instance._logger.warning("No stream handler found to update formatter.")
+
+    @staticmethod
+    def enable_remote_logging(endpoint, app_id):
+        instance = UnmanicLogging()
+        if instance.remote_handler:
+            instance._logger.info("Remote logging is already enabled.")
+            return
+
+        json_formatter = ForwardJSONFormatter()
+        buffer_path = os.path.join(instance._log_path, "buffer")
+        instance.remote_handler = ForwardLogHandler(endpoint, buffer_path, app_id)
+        instance.remote_handler.setFormatter(json_formatter)
+        instance._logger.addHandler(instance.remote_handler)
+        instance._logger.info("Remote logging enabled.")
+
+    @staticmethod
+    def disable_remote_logging():
+        instance = UnmanicLogging()
+        if not instance.remote_handler:
+            instance._logger.info("Remote logging is already disabled.")
+            return
+
+        instance._logger.removeHandler(instance.remote_handler)
+        instance.remote_handler.close()
+        instance.remote_handler = None
+        instance._logger.info("Remote logging disabled.")
diff --git a/unmanic/libs/plugins.py b/unmanic/libs/plugins.py
index dabb94f0..65f7af3b 100644
--- a/unmanic/libs/plugins.py
+++ b/unmanic/libs/plugins.py
@@ -40,8 +40,9 @@
 import requests
 
 from unmanic import config
-from unmanic.libs import common, unlogger
+from unmanic.libs import common
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.session import Session
 from unmanic.libs.singleton import SingletonType
 from unmanic.libs.unmodels import EnabledPlugins, LibraryPluginFlow, Plugins, PluginRepos
@@ -57,8 +58,7 @@ class PluginsHandler(object, metaclass=SingletonType):
 
     def __init__(self, *args, **kwargs):
         self.settings = config.Config()
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def _log(self, message, message2='', level="info"):
         message = common.format_message(message, message2)
@@ -141,8 +141,17 @@ def fetch_remote_repo_data(self, repo_path):
             1,
             api_path,
         )
+        if status_code == 401:
+            # Something is wrong with registration. Let's resend it and try again.
+            self.logger.debug(f"Plugin repo returned a request to register. Code:{status_code}")
+            session.register_unmanic()
+            data, status_code = session.api_get(
+                'unmanic-api',
+                1,
+                api_path,
+            )
         if status_code >= 500:
-            self._log(f"Failed to fetch plugin repo from '{api_path}'. Code:{status_code}", level="debug")
+            self.logger.debug(f"Failed to fetch plugin repo from '{api_path}'. Code:{status_code}")
         return data
 
     def update_plugin_repos(self):
@@ -164,12 +173,12 @@ def update_plugin_repos(self):
 
             # Dumb object to local JSON file
             repo_cache = self.get_repo_cache_file(repo_id)
-            self._log("Repo cache file '{}'.".format(repo_cache), level="info")
+            self.logger.info("Repo cache file '%s'.", repo_cache)
             try:
                 with open(repo_cache, 'w') as f:
                     json.dump(repo_data, f, indent=4)
             except json.JSONDecodeError as e:
-                self._log("Unable to update plugin repo '{}'.".format(repo_path), str(e), level="error")
+                self.logger.error("Unable to update plugin repo '%s'. %s", repo_path, str(e))
         return True
 
     def get_settings_of_all_installed_plugins(self):
@@ -329,7 +338,7 @@ def notify_site_of_plugin_install(self, plugin):
             if not repo_data.get('success'):
                 session.register_unmanic()
         except Exception as e:
-            self._log("Exception while logging plugin install.", str(e), level="debug")
+            self.logger.debug("Exception while logging plugin install. %s", str(e))
             return False
 
     def install_plugin_by_id(self, plugin_id, repo_id=None):
@@ -353,7 +362,7 @@ def install_plugin_by_id(self, plugin_id, repo_id=None):
                         plugin_directory = self.get_plugin_path(plugin.get("plugin_id"))
                         result = self.write_plugin_data_to_db(plugin, plugin_directory)
                         if result:
-                            self._log("Installed plugin '{}'".format(plugin_id), level="info")
+                            self.logger.info("Installed plugin '%s'", plugin_id)
 
                         # Ensure the plugin module is reloaded (if it was previously loaded)
                         plugin_executor = PluginExecutor()
@@ -361,7 +370,7 @@ def install_plugin_by_id(self, plugin_id, repo_id=None):
 
                         return result
                     except Exception as e:
-                        self._log("Exception while installing plugin '{}'.".format(plugin), str(e), level="exception")
+                        self.logger.exception("Exception while installing plugin '%s'.", plugin)
 
         return False
 
@@ -388,7 +397,7 @@ def install_plugin_from_path_on_disk(self, abspath):
             plugin_directory = self.get_plugin_path(plugin_info.get("plugin_id"))
             result = self.write_plugin_data_to_db(plugin_info, plugin_directory)
             if result:
-                self._log("Installed plugin '{}'".format(plugin_info.get("plugin_id")), level="info")
+                self.logger.info("Installed plugin '%s'", plugin_info.get("plugin_id"))
 
             # Ensure the plugin module is reloaded (if it was previously loaded)
             plugin_executor = PluginExecutor()
@@ -396,7 +405,7 @@ def install_plugin_from_path_on_disk(self, abspath):
 
             return result
         except Exception as e:
-            self._log("Exception while installing plugin from zip '{}'.".format(abspath), str(e), level="exception")
+            self.logger.exception("Exception while installing plugin from zip '%s'. %s", abspath, str(e))
 
         return False
 
@@ -407,7 +416,7 @@ def download_and_install_plugin(self, plugin):
         :param plugin:
         :return:
         """
-        self._log("Installing plugin '{}'".format(plugin.get("name")), level='debug')
+        self.logger.debug("Installing plugin '%s'", plugin.get("name"))
         # Try to fetch URL
         try:
             # Fetch remote zip file
@@ -425,8 +434,7 @@ def download_and_install_plugin(self, plugin):
             return True
 
         except Exception as e:
-            success = False
-            self._log("Exception while installing plugin '{}'.".format(plugin), str(e), level="exception")
+            self.logger.exception("Exception while installing plugin '%s'. %s", plugin, str(e))
 
         return False
 
@@ -439,7 +447,7 @@ def download_plugin(self, plugin):
         """
         # Fetch remote zip file
         destination = self.get_plugin_download_cache_path(plugin.get("plugin_id"), plugin.get("version"))
-        self._log("Downloading plugin '{}' to '{}'".format(plugin.get("package_url"), destination), level='debug')
+        self.logger.debug("Downloading plugin '%s' to '%s'", plugin.get("package_url"), destination)
         with requests.get(plugin.get("package_url"), stream=True, allow_redirects=True) as r:
             r.raise_for_status()
             with open(destination, 'wb') as f:
@@ -463,11 +471,11 @@ def install_plugin(self, zip_file, plugin_id=None):
         # Create plugin destination directory based on plugin ID
         plugin_directory = self.get_plugin_path(plugin_id)
         # Prevent installation if destination has a git repository. This plugin is probably under development
-        self._log(os.path.join(str(plugin_directory), '.git'))
+        self.logger.info(os.path.join(str(plugin_directory), '.git'))
         if os.path.exists(os.path.join(str(plugin_directory), '.git')):
             raise Exception("Plugin directory contains a git repository. Uninstall this source version before installing.")
         # Extract zip file contents
-        self._log("Extracting plugin to '{}'".format(plugin_directory), level='debug')
+        self.logger.debug("Extracting plugin to '{}'".format(plugin_directory))
         with zipfile.ZipFile(zip_file, "r") as zip_ref:
             zip_ref.extractall(str(plugin_directory))
         # Return installed plugin info
@@ -560,10 +568,10 @@ def get_plugin_list_filtered_and_sorted(self, order=None, start=0, length=None,
 
         except Plugins.DoesNotExist:
             # No plugin entries exist yet
-            self._log("No plugins exist yet.", level="warning")
+            self.logger.warning("No plugins exist yet.")
 
     def flag_plugin_for_update_by_id(self, plugin_id):
-        self._log("Flagging update available for installed plugin '{}'".format(plugin_id), level='debug')
+        self.logger.debug("Flagging update available for installed plugin '%s'", plugin_id)
         # Disable the matching entries in the table
         Plugins.update(update_available=True).where(Plugins.plugin_id == plugin_id).execute()
 
@@ -574,7 +582,7 @@ def flag_plugin_for_update_by_id(self, plugin_id):
         for record in records:
             if record.get('update_available'):
                 continue
-            self._log("Failed to flag plugin for update '{}'".format(record.get('plugin_id')), level='debug')
+            self.logger.debug("Failed to flag plugin for update '%s'", record.get('plugin_id'))
             return False
 
         return True
@@ -587,7 +595,7 @@ def uninstall_plugins_by_db_table_id(self, plugin_table_ids: list):
         :param plugin_table_ids:
         :return:
         """
-        self._log("Uninstall plugins '{}'".format(plugin_table_ids), level='debug')
+        self.logger.debug("Uninstall plugins '%s'", plugin_table_ids)
 
         # Fetch records
         records_by_id = self.get_plugin_list_filtered_and_sorted(id_list=plugin_table_ids)
@@ -626,7 +634,7 @@ def uninstall_plugins_by_db_table_id(self, plugin_table_ids: list):
         return True
 
     def update_plugins_by_db_table_id(self, plugin_table_ids):
-        self._log("Update plugins '{}'".format(plugin_table_ids), level='debug')
+        self.logger.debug("Update plugins '%s'", plugin_table_ids)
 
         # Fetch records
         records_by_id = self.get_plugin_list_filtered_and_sorted(id_list=plugin_table_ids)
@@ -635,7 +643,7 @@ def update_plugins_by_db_table_id(self, plugin_table_ids):
         for record in records_by_id:
             if self.install_plugin_by_id(record.get('plugin_id')):
                 continue
-            self._log("Failed to update plugin '{}'".format(record.get('plugin_id')), level='debug')
+            self.logger.debug("Failed to update plugin '%s'", record.get('plugin_id'))
             return False
 
         return True
diff --git a/unmanic/libs/postprocessor.py b/unmanic/libs/postprocessor.py
index e85d425e..4f249c3a 100644
--- a/unmanic/libs/postprocessor.py
+++ b/unmanic/libs/postprocessor.py
@@ -37,6 +37,7 @@
 from unmanic import config
 from unmanic.libs import common, history
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.notifications import Notifications
 from unmanic.libs.plugins import PluginsHandler
 
@@ -67,7 +68,7 @@ class PostProcessor(threading.Thread):
 
     def __init__(self, data_queues, task_queue, event):
         super(PostProcessor, self).__init__(name='PostProcessor')
-        self.logger = data_queues["logging"].get_logger(self.name)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.event = event
         self.data_queues = data_queues
         self.settings = config.Config()
diff --git a/unmanic/libs/scheduler.py b/unmanic/libs/scheduler.py
index e02e8837..42529271 100644
--- a/unmanic/libs/scheduler.py
+++ b/unmanic/libs/scheduler.py
@@ -37,8 +37,9 @@
 import schedule
 
 from unmanic import config
-from unmanic.libs import common, task, unlogger
+from unmanic.libs import task
 from unmanic.libs.installation_link import Links
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.plugins import PluginsHandler
 from unmanic.libs.session import Session
 
@@ -50,25 +51,18 @@ class ScheduledTasksManager(threading.Thread):
 
     def __init__(self, event):
         super(ScheduledTasksManager, self).__init__(name='ScheduledTasksManager')
-        self.logger = None
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.event = event
         self.abort_flag = threading.Event()
         self.abort_flag.clear()
         self.scheduler = schedule.Scheduler()
         self.force_local_worker_timer = 0
 
-    def _log(self, message, message2='', level="info"):
-        if not self.logger:
-            unmanic_logging = unlogger.UnmanicLogger.__call__()
-            self.logger = unmanic_logging.get_logger(self.name)
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def stop(self):
         self.abort_flag.set()
 
     def run(self):
-        self._log("Starting ScheduledTasks Monitor loop")
+        self.logger.info("Starting ScheduledTasks Monitor loop")
 
         # Create scheduled tasks
         # Check the session every 60 minutes
@@ -91,15 +85,15 @@ def run(self):
 
         # Clear any tasks and exit
         self.scheduler.clear()
-        self._log("Leaving ScheduledTasks Monitor loop...")
+        self.logger.info("Leaving ScheduledTasks Monitor loop...")
 
     def register_unmanic(self):
-        self._log("Updating session data")
+        self.logger.info("Updating session data")
         s = Session()
         s.register_unmanic(force=True)
 
     def plugin_repo_update(self):
-        self._log("Checking for updates to plugin repos")
+        self.logger.info("Checking for updates to plugin repos")
         plugin_handler = PluginsHandler()
         plugin_handler.update_plugin_repos()
 
@@ -131,7 +125,7 @@ def set_worker_count_based_on_remote_installation_links(self):
             return
 
         # There is a link config with distributed worker counts enabled
-        self._log("Syncing distributed worker count for this installation")
+        self.logger.info("Syncing distributed worker count for this installation")
 
         # Get total tasks count of pending tasks across all linked_configs
         total_tasks = local_task_count
@@ -165,7 +159,7 @@ def set_worker_count_based_on_remote_installation_links(self):
                 target_workers_for_this_installation = 1
                 self.force_local_worker_timer = time_now
 
-        self._log("Configuring worker count as {} for this installation".format(target_workers_for_this_installation))
+        self.logger.info("Configuring worker count as %s for this installation", target_workers_for_this_installation)
         settings.set_config_item('number_of_workers', target_workers_for_this_installation, save_settings=True)
 
     def manage_completed_tasks(self):
@@ -174,7 +168,7 @@ def manage_completed_tasks(self):
         if not settings.get_auto_manage_completed_tasks():
             return
 
-        self._log("Running completed task cleanup for this installation")
+        self.logger.info("Running completed task cleanup for this installation")
         max_age_in_days = settings.get_max_age_of_completed_tasks()
         date_x_days_ago = datetime.now() - timedelta(days=int(max_age_in_days))
         before_time = date_x_days_ago.timestamp()
@@ -194,13 +188,13 @@ def manage_completed_tasks(self):
                                                                              before_time=before_time)
 
         if count == 0:
-            self._log("Found no {} completed tasks older than {} days".format(inc_status, max_age_in_days))
+            self.logger.info("Found no %s completed tasks older than %s days", inc_status, max_age_in_days)
             return
 
-        self._log(
-            "Found {} {} completed tasks older than {} days that should be removed".format(count, inc_status, max_age_in_days))
+        self.logger.info("Found %s %s completed tasks older than %s days that should be removed", count, inc_status,
+                         max_age_in_days)
         if not history_logging.delete_historic_tasks_recursively(results):
-            self._log("Failed to delete {} {} completed tasks".format(count, inc_status), level='error')
+            self.logger.error("Failed to delete %s %s completed tasks", count, inc_status)
             return
 
-        self._log("Deleted {} {} completed tasks".format(count, inc_status))
+        self.logger.info("Deleted %s %s completed tasks", count, inc_status)
diff --git a/unmanic/libs/session.py b/unmanic/libs/session.py
index a5f0a323..8c6db1cc 100644
--- a/unmanic/libs/session.py
+++ b/unmanic/libs/session.py
@@ -31,6 +31,7 @@
 """
 import base64
 import datetime
+import os
 import pickle
 import random
 import time
@@ -38,7 +39,7 @@
 import requests
 
 from unmanic import config
-from unmanic.libs import common, unlogger
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.singleton import SingletonType
 from unmanic.libs.unmodels import Installation
 
@@ -114,21 +115,16 @@ class Session(object, metaclass=SingletonType):
     user_access_token = None
 
     """
-    user_refresh_token - The refresh token for acquiring an updated access token
+    application_token - The application token for acquiring an updated access token
     """
-    user_refresh_token = None
-
-    """
-    session_cookies - A stored copy of the session cookies to persist between restarts
-    """
-    session_cookies = None
+    application_token = None
 
     def __init__(self, *args, **kwargs):
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.timeout = 30
         self.dev_api = kwargs.get('dev_api', None)
         self.requests_session = requests.Session()
+        self.token_poll_task = None
         self.logger.info('Initialising new session object')
 
     def __created_older_than_x_days(self, days=1):
@@ -203,14 +199,13 @@ def __fetch_installation_data(self):
         self.uuid = str(current_installation.uuid)
         self.level = int(current_installation.level)
         self.picture_uri = str(current_installation.picture_uri)
-        self.name = str(current_installation.name)
+        self.name = str(current_installation.name)  # This is the user's name. Not the installation's name
         self.email = str(current_installation.email)
         self.created = current_installation.created if current_installation.created else None
         if isinstance(self.created, datetime.datetime):
             self.created = self.created.timestamp()
 
-        self.__update_session_auth(access_token=current_installation.user_access_token,
-                                   session_cookies=current_installation.session_cookies)
+        self.__update_session_auth(access_token=current_installation.user_access_token)
 
     def __store_installation_data(self, force_save_access_token=False):
         """
@@ -222,17 +217,24 @@ def __store_installation_data(self, force_save_access_token=False):
             db_installation = Installation.get_or_none(uuid=self.uuid)
             db_installation.level = self.level
             db_installation.picture_uri = self.picture_uri
-            db_installation.name = self.name
+            db_installation.name = self.name  # This is the user's name. Not the installation's name
             db_installation.email = self.email
             db_installation.created = self.created
             if self.user_access_token or force_save_access_token:
                 db_installation.user_access_token = self.user_access_token
-            if self.user_refresh_token or force_save_access_token:
-                db_installation.user_refresh_token = self.user_refresh_token
-            if self.session_cookies or force_save_access_token:
-                db_installation.session_cookies = self.session_cookies
+            if self.application_token or force_save_access_token:
+                db_installation.application_token = self.application_token
             db_installation.save()
 
+    def __configure_log_forwarding(self, session_valid=False):
+        if session_valid:
+            # TODO: Fetch endpoint from unmanic-api
+            endpoint = os.environ.get('UNMANIC_REMOTE_LOGING_ENDPOINT')
+            if endpoint:
+                UnmanicLogging.enable_remote_logging(endpoint, self.uuid)
+                return
+        UnmanicLogging.disable_remote_logging()
+
     def __reset_session_installation_data(self):
         """
         Reset stored session data
@@ -246,22 +248,16 @@ def __reset_session_installation_data(self):
         self.email = ''
         self.created = time.time()
         self.user_access_token = None
-        self.user_refresh_token = None
+        self.application_token = None
         self.__store_installation_data(force_save_access_token=True)
+        self.__configure_log_forwarding(session_valid=False)
         self.__clear_session_auth()
 
-    def __update_session_auth(self, access_token=None, session_cookies=None):
+    def __update_session_auth(self, access_token=None):
         # Update session headers
         if access_token:
             self.user_access_token = access_token
             self.requests_session.headers.update({'Authorization': self.user_access_token})
-        # Update session cookies
-        if session_cookies:
-            self.session_cookies = session_cookies
-            try:
-                self.requests_session.cookies = pickle.loads(base64.b64decode(session_cookies))
-            except Exception as e:
-                self.logger.error('Error trying to reload session cookies - %s', str(e))
 
     def __clear_session_auth(self):
         self.requests_session.cookies.clear()
@@ -368,51 +364,52 @@ def api_post(self, api_prefix, api_version, api_path, data):
                 self.logger.debug('Failed to verify auth (api_post)')
         return r.json(), r.status_code
 
-    def verify_token(self):
-        if not self.user_access_token:
-            # No valid tokens exist
-            return False
-        # Check if access token is valid
-        u = self.set_full_api_url('support-auth-api', 1, 'user_auth/verify_token')
-        r = self.requests_session.get(u, timeout=self.timeout)
-        if r.status_code in [202]:
-            # Token is valid
-            return True
-        elif r.status_code > 403:
-            # Issue with server... Just carry on with current access token can't fix that here.
-            raise RemoteApiException(f"Token verification request failed for {u}", r.status_code)
-
-        # Access token is not valid. Refresh it.
-        self.logger.debug('Unable to verify authentication token. Refreshing...')
-        d = {"refreshToken": self.user_refresh_token}
-        u = self.set_full_api_url('support-auth-api', 1, 'user_auth/token')
+    def get_access_token(self):
+        d = {"applicationToken": self.application_token, "uuid": self.get_installation_uuid()}
+        u = self.set_full_api_url('support-auth-api', 2, 'app_auth/get_token')
         r = self.requests_session.post(u, json=d, timeout=self.timeout)
-        if r.status_code in [202]:
+        if r.status_code in [200, 201, 202]:
             # Token refreshed
             # Store the updated access token
             response = r.json()
             self.__update_session_auth(access_token=response.get('data', {}).get('accessToken'))
-            # Store the updated refresh token
-            self.user_refresh_token = response.get('data', {}).get('refreshToken')
-            # Store the updated session cookies
-            self.session_cookies = base64.b64encode(pickle.dumps(self.requests_session.cookies)).decode('utf-8')
             self.__store_installation_data()
+            self.__configure_log_forwarding(session_valid=True)
             return True
         elif r.status_code > 403:
             # Issue was with server... Just carry on with current access token can't fix that here.
             raise RemoteApiException(f"Token refresh request failed for {u}", r.status_code)
         elif r.status_code in [403]:
             # Log this failure in the debug logs
-            self.logger.info('Failed to refresh access token.')
+            self.logger.info('Failed to get access token.')
             response = r.json()
             for message in response.get('messages', []):
                 self.logger.info('Remote Message: %s', message)
-        # Just blank the class attribute.
-        # It is fine for requests to be sent with further requests.
-        # User will appear to be logged out.
-        self.user_access_token = None
         return False
 
+    def verify_token(self):
+        if not self.user_access_token:
+            # No valid tokens exist
+            return False
+        # Check if access token is valid
+        u = self.set_full_api_url('support-auth-api', 1, 'user_auth/verify_token')
+        r = self.requests_session.get(u, timeout=self.timeout)
+        if r.status_code in [200, 201, 202]:
+            # Token is valid
+            return True
+        elif r.status_code > 403:
+            # Issue with server... Just carry on with current access token can't fix that here.
+            raise RemoteApiException(f"Token verification request failed for {u}", r.status_code)
+
+        # Access token is not valid. Refresh it.
+        self.logger.debug('Unable to verify access token. Refreshing...')
+        if not self.get_access_token():
+            # Blank the class attribute.
+            # It is fine for requests to be sent with further requests.
+            # User will appear to be logged out.
+            self.user_access_token = None
+            return False
+
     def fetch_user_data(self):
         # Set default level to 0
         updated_level = 0
@@ -439,31 +436,22 @@ def auth_user_account(self, force_checkin=False):
         if not self.user_access_token and not force_checkin:
             self.logger.debug('The user access token is not set add we are not being forced to refresh for one.')
             return False
+
         # Start by verifying the token
         token_verified = self.verify_token()
-        if not token_verified and force_checkin:
-            # Try to fetch token if this was the initial login
-            post_data = {"uuid": self.get_installation_uuid()}
-            response, status_code = self.api_post('support-auth-api', 1, 'app_auth/retrieve_app_token', post_data)
-            if status_code in [200, 201, 202] and response.get('success'):
-                # Store the updated access token
-                self.__update_session_auth(access_token=response.get('data', {}).get('accessToken'))
-                # Store the updated refresh token
-                self.user_refresh_token = response.get('data', {}).get('refreshToken')
-                token_verified = self.verify_token()
-            elif status_code > 403:
-                raise RemoteApiException("Failed to fetch initial app token frp, app_auth/retrieve_app_token", status_code)
-            else:
-                self.logger.info('Failed to check in with Unmanic support auth API.')
-                for message in response.get('messages', []):
-                    self.logger.info('Remote Message: %s', message)
-        # Finally, fetch user info if the token was successfully verified
+
+        # If that token verification failed but we are not being forced to check in, then just ignore it.
+        if not token_verified and not force_checkin:
+            self.logger.debug('The user access token is not valid but we are not being forced to refresh for one.')
+            return False
+
+        # If the token was verified and is valid, fetch user info
         if token_verified:
             self.level = self.fetch_user_data()
             return True
-        else:
-            # Set default level to 0
-            self.level = 0
+
+        # Finally, if no valid session and no user account (and at this point force_checkin was True), run the sign-out process
+        self.sign_out()
         return False
 
     def auth_trial_account(self):
@@ -471,7 +459,7 @@ def auth_trial_account(self):
         d = {"uuid": self.get_installation_uuid()}
         u = self.set_full_api_url('support-auth-api', 1, 'user_auth/trial_token')
         r = self.requests_session.post(u, json=d, timeout=self.timeout)
-        if r.status_code in [202]:
+        if r.status_code in [200, 201, 202]:
             # Token refreshed
             # Store the updated access token
             response = r.json()
@@ -480,6 +468,7 @@ def auth_trial_account(self):
             self.level = self.fetch_user_data()
             # Store the updated session cookies
             self.__store_installation_data()
+            self.__configure_log_forwarding(session_valid=True)  # TODO: Remove from here. It wont work with trials.
             return True
         elif r.status_code > 403:
             # Issue with server... Just carry on with current access token can't fix that here.
@@ -519,10 +508,11 @@ def register_unmanic(self, force=False):
             if platform_info:
                 platform_info = " * ".join(platform_info)
             post_data = {
-                "uuid":           self.get_installation_uuid(),
-                "version":        settings.read_version(),
-                "python_version": system_info.get("python", ''),
-                "system":         {
+                "uuid":              self.get_installation_uuid(),
+                "installation_name": settings.get_installation_name(),
+                "version":           settings.read_version(),
+                "python_version":    system_info.get("python", ''),
+                "system":            {
                     "platform": platform_info,
                     "devices":  system_info.get("devices", {}),
                 }
@@ -530,7 +520,7 @@ def register_unmanic(self, force=False):
 
             # Refresh user auth
             result = self.auth_user_account(force_checkin=force)
-            if not result:
+            if not result and force:
                 # Fetch trial token
                 result = self.auth_trial_account()
 
@@ -542,6 +532,7 @@ def register_unmanic(self, force=False):
                 self.__update_created_timestamp()
                 # Persist session in DB
                 self.__store_installation_data()
+                self.__configure_log_forwarding(session_valid=True)
                 return True
             elif status_code > 403:
                 raise RemoteApiException("Failed to register installation to installation_auth/register", status_code)
@@ -552,7 +543,7 @@ def register_unmanic(self, force=False):
                 self.__reset_session_installation_data()
             return False
         except RemoteApiException as e:
-            self.logger.error("Exception while registering Unmanic: %s", e)
+            self.logger.error("Exception while registering Unmanic with remote API: %s", e)
         except Exception as e:
             self.logger.debug("Exception while registering Unmanic: %s", e, exc_info=True)
             if self.__check_session_valid():
@@ -585,6 +576,95 @@ def get_sign_out_url(self):
         """
         return "{0}/unmanic-api/v1/installation_auth/logout".format(self.get_site_url())
 
+    def init_device_auth_flow(self):
+        """
+        Starts the device authentication flow to obtain an application token.
+        It sends a POST request for a device code and then polls until the app token is available.
+
+        It then logs the verification URL and user code for the user to enter, and finally
+        calls poll_for_app_token() to retrieve the app token.
+        """
+        # Construct the AuthAPIBase using self.get_site_url()
+        auth_api_base = f"{self.get_site_url()}/support-auth-api"
+        request_body = {
+            "uuid": self.get_installation_uuid()
+        }
+        url = f"{auth_api_base}/v2/app_auth/request_pin"
+
+        try:
+            response = requests.post(url, json=request_body, headers={"Content-Type": "application/json"})
+        except requests.RequestException as e:
+            self.logger.error("The remote service is currently unavailable. Please try again later.")
+            raise e
+
+        # Try to fetch token if this was the initial login
+        post_data = {"uuid": self.get_installation_uuid()}
+        response, status_code = self.api_post('support-auth-api', 2, 'app_auth/request_pin', post_data)
+        if status_code >= 400:
+            self.logger.error(
+                "The remote service returned an error (HTTP %s). We are unable to proceed at this time. Please try again later.",
+                status_code)
+            return False
+
+        if status_code != 200:
+            raise Exception(f"Unexpected response status: {status_code}")
+
+        if not response.get("success"):
+            raise Exception("Device auth request was unsuccessful: " + str(response.get("messages")))
+
+        data = response.get("data", {})
+        user_code = data.get("user_code")
+        device_code = data.get("device_code")
+        verification_uri = data.get("verification_uri")
+        verification_uri_complete = data.get("verification_uri_complete")
+        interval = data.get("interval")
+        expires_in = data.get("expires_in")
+
+        self.logger.info("Visit %s and enter the code: %s", verification_uri, user_code)
+
+        # Begin polling for the application token using the device code, interval, and expiry
+        return {
+            "user_code":                 user_code,
+            "device_code":               device_code,
+            "interval":                  interval,
+            "expires_in":                expires_in,
+            "verification_uri":          verification_uri,
+            "verification_uri_complete": verification_uri_complete
+        }
+
+    def poll_for_app_token(self, device_code, interval, expires_in):
+        """
+        Polls the remote API for the application token.
+        This function is intended to run in a background thread.
+        It runs for a maximum of "expires_in" seconds.
+        """
+        start_time = time.time()
+        self.logger.info("Polling for app token")
+        while time.time() - start_time < expires_in:
+            time.sleep(interval)
+
+            # Try to fetch token if this was the initial login
+            post_data = {
+                "uuid":        self.get_installation_uuid(),
+                "device_code": device_code,
+            }
+            response, status_code = self.api_post('support-auth-api', 2, 'app_auth/retrieve_app_token', post_data)
+            if status_code > 403:
+                # Issue with server... Just carry on with current access token can't fix that here.
+                raise RemoteApiException("App token retrieval request failed for %s", status_code)
+            elif status_code in [200] and response.get('data', {}).get('applicationToken'):
+                # Store the updated access token
+                self.logger.info("Application linked to account")
+                # Store the updated refresh token
+                self.application_token = response.get('data', {}).get('applicationToken')
+                self.get_access_token()
+                token_verified = self.verify_token()
+                self.logger.info("Application auth token verified: %s", token_verified)
+                return token_verified
+
+        self.logger.info("Polling for app token timed out after %s seconds.", expires_in)
+        return None
+
     def get_patreon_login_url(self):
         """
         Fetch the Patreon Login URL
diff --git a/unmanic/libs/system.py b/unmanic/libs/system.py
index ba101af7..a98559f5 100644
--- a/unmanic/libs/system.py
+++ b/unmanic/libs/system.py
@@ -29,7 +29,7 @@
            OR OTHER DEALINGS IN THE SOFTWARE.
 
 """
-from unmanic.libs import unlogger, common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.singleton import SingletonType
 
 
@@ -40,12 +40,7 @@ class System(object, metaclass=SingletonType):
     python_version = {}
 
     def __init__(self, *args, **kwargs):
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
-
-    def _log(self, message, message2='', level="info"):
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def __get_python_info(self):
         """
diff --git a/unmanic/libs/task.py b/unmanic/libs/task.py
index 671fcd97..92c16afc 100644
--- a/unmanic/libs/task.py
+++ b/unmanic/libs/task.py
@@ -38,8 +38,9 @@
 from playhouse.shortcuts import model_to_dict
 
 from unmanic import config
-from unmanic.libs import common, unlogger
+from unmanic.libs import common
 from unmanic.libs.library import Library
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.unmodels.tasks import IntegrityError, Tasks
 
 
@@ -73,15 +74,10 @@ def __init__(self):
         self.task = None
         self.task_dict = None
         self.settings = config.Config()
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.statistics = {}
         self.errors = []
 
-    def _log(self, message, message2='', level="info"):
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def set_cache_path(self, cache_directory=None, file_extension=None):
         if not self.task:
             raise Exception('Unable to set cache path. Task has not been set!')
@@ -213,7 +209,7 @@ def create_task_by_absolute_path(self, abspath, task_type='local', library_id=1,
         try:
             self.task = Tasks.create(abspath=abspath, status='creating', library_id=library_id)
             self.save()
-            self._log("Created new task with ID: {} for {}".format(self.task, abspath), level="debug")
+            self.logger.debug("Created new task with ID: %s for %s", self.task, abspath)
 
             # Set the cache path to use during the transcoding
             self.set_cache_path()
@@ -239,7 +235,7 @@ def create_task_by_absolute_path(self, abspath, task_type='local', library_id=1,
 
             return True
         except IntegrityError as e:
-            self._log("Cancel creating new task for {} - {}".format(abspath, e), level="info")
+            self.logger.info("Cancel creating new task for %s - %s", abspath, e)
             return False
 
     def set_status(self, status):
@@ -350,7 +346,7 @@ def get_task_list_filtered_and_sorted(self, order=None, start=0, length=None, se
 
         except Tasks.DoesNotExist:
             # No task entries exist yet
-            self._log("No tasks exist yet.", level="warning")
+            self.logger.warning("No tasks exist yet.")
             query = []
 
         return query.dicts()
@@ -378,20 +374,20 @@ def delete_tasks_recursively(self, id_list):
                     if task_id.type == 'remote':
                         remote_task_dirname = task_id.abspath
                         if os.path.exists(task_id.abspath) and "unmanic_remote_pending_library" in remote_task_dirname:
-                            self._log("Removing remote pending library task '{}'.".format(remote_task_dirname))
+                            self.logger.info("Removing remote pending library task '%s'.", remote_task_dirname)
                             shutil.rmtree(os.path.dirname(remote_task_dirname))
 
                     task_id.delete_instance(recursive=True)
                 except Exception as e:
                     # Catch delete exceptions
-                    self._log("An error occurred while deleting task ID: {}.".format(task_id), str(e), level="exception")
+                    self.logger.exception("An error occurred while deleting task ID: %s. %s", task_id, e)
                     return False
 
             return True
 
         except Tasks.DoesNotExist:
             # No task entries exist yet
-            self._log("No tasks currently exist.", level="warning")
+            self.logger.warning("No tasks currently exist.")
 
     def reorder_tasks(self, id_list, direction):
         # Get the task with the highest ID
diff --git a/unmanic/libs/taskhandler.py b/unmanic/libs/taskhandler.py
index 7ef4b353..ef090a5e 100644
--- a/unmanic/libs/taskhandler.py
+++ b/unmanic/libs/taskhandler.py
@@ -36,6 +36,7 @@
 
 from unmanic import config
 from unmanic.libs import common, task
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.unmodels.tasks import Tasks
 
 
@@ -59,7 +60,7 @@ def __init__(self, data_queues, task_queue, event):
         self.settings = config.Config()
         self.event = event
         self.data_queues = data_queues
-        self.logger = data_queues["logging"].get_logger(self.name)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.task_queue = task_queue
         self.inotifytasks = data_queues["inotifytasks"]
         self.scheduledtasks = data_queues["scheduledtasks"]
diff --git a/unmanic/libs/taskqueue.py b/unmanic/libs/taskqueue.py
index 4635879b..2fc9d432 100644
--- a/unmanic/libs/taskqueue.py
+++ b/unmanic/libs/taskqueue.py
@@ -32,6 +32,7 @@
 
 from unmanic.libs import task
 from unmanic.libs import common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.unmodels import Libraries, LibraryTags, Tags
 from unmanic.libs.unmodels.tasks import Tasks
 
@@ -166,7 +167,7 @@ class TaskQueue(object):
     def __init__(self, data_queues):
         self.name = 'TaskQueue'
         self.data_queues = data_queues
-        self.logger = data_queues["logging"].get_logger(self.name)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
         # Sort fields
         self.sort_by = Tasks.priority
diff --git a/unmanic/libs/uiserver.py b/unmanic/libs/uiserver.py
index 8d502801..76474575 100644
--- a/unmanic/libs/uiserver.py
+++ b/unmanic/libs/uiserver.py
@@ -44,6 +44,7 @@
 
 from unmanic import config
 from unmanic.libs import common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.singleton import SingletonType
 from unmanic.webserver.downloads import DownloadsHandler
 
@@ -199,10 +200,10 @@ class UIServer(threading.Thread):
     def __init__(self, unmanic_data_queues, foreman, developer):
         super(UIServer, self).__init__(name='UIServer')
         self.config = config.Config()
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
         self.developer = developer
         self.data_queues = unmanic_data_queues
-        self.logger = unmanic_data_queues["logging"].get_logger(self.name)
         self.inotifytasks = unmanic_data_queues["inotifytasks"]
         # TODO: Move all logic out of template calling to foreman.
         #  Create methods here to handle the calls and rename to foreman
diff --git a/unmanic/libs/unlogger.py b/unmanic/libs/unlogger.py
deleted file mode 100644
index 430e3445..00000000
--- a/unmanic/libs/unlogger.py
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-    unmanic.unlogger.py
-
-    Written by:               Josh.5 <jsunnex@gmail.com>
-    Date:                     06 Jan 2019, (8:41 AM)
-
-    Copyright:
-           Copyright (C) Josh Sunnex - All Rights Reserved
-
-           Permission is hereby granted, free of charge, to any person obtaining a copy
-           of this software and associated documentation files (the "Software"), to deal
-           in the Software without restriction, including without limitation the rights
-           to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-           copies of the Software, and to permit persons to whom the Software is
-           furnished to do so, subject to the following conditions:
-
-           The above copyright notice and this permission notice shall be included in all
-           copies or substantial portions of the Software.
-
-           THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-           EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-           MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-           IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-           DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-           OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
-           OR OTHER DEALINGS IN THE SOFTWARE.
-
-"""
-
-import os
-import logging
-
-from unmanic.libs.singleton import SingletonType
-
-
-class UnmanicLogger(object, metaclass=SingletonType):
-    _enable_log_to_file = None
-    stream_handler = None
-    file_handler = None
-    _settings = None
-    _logger = None
-
-    def __init__(self, log_to_file=True):
-        self._enable_log_to_file = log_to_file
-        # Create our default parent logger and set the default level to info
-        self._logger = logging.getLogger("Unmanic")
-        # Initially set this logger to INFO (once the config is applied, this may change)
-        self._logger.setLevel(logging.INFO)
-        # Prevent logging from being passed up the chain
-        self._logger.propagate = False
-
-        # Create formatter
-        self.formatter = logging.Formatter(
-            '%(asctime)s:%(levelname)s:%(name)s - %(message)s',
-            datefmt='%Y-%m-%dT%H:%M:%S'
-        )
-        # Add stream handler
-        if not self.stream_handler:
-            # Create file handler
-            self.stream_handler = logging.StreamHandler()
-            # Apply formatter
-            self.stream_handler.setFormatter(self.formatter)
-            # Set the log level of the stream handle
-            self.stream_handler.setLevel(logging.INFO)
-            # Add handler
-            self._logger.addHandler(self.stream_handler)
-        # Add file handler
-        self.setup_file_handler()
-
-    def setup_file_handler(self):
-        if self._enable_log_to_file and not self.file_handler and self._settings and self._settings.get_log_path():
-            # Create directory if not exists
-            if not os.path.exists(self._settings.get_log_path()):
-                os.makedirs(self._settings.get_log_path())
-            # Create file handler
-            log_file = os.path.join(self._settings.get_log_path(), 'unmanic.log')
-            self.file_handler = logging.handlers.TimedRotatingFileHandler(log_file, when='midnight', interval=1,
-                                                                          backupCount=7)
-            # Apply formatter
-            self.file_handler.setFormatter(self.formatter)
-            # Set log level of file handler...
-            if self._settings.get_debugging():
-                self.file_handler.setLevel(logging.DEBUG)
-            else:
-                self.file_handler.setLevel(logging.INFO)
-            # Set the log level of the stream handle always to error
-            self.stream_handler.setLevel(logging.CRITICAL)
-            # Add handler
-            self._logger.addHandler(self.file_handler)
-
-    def disable_file_handler(self, debugging=False):
-        # Set the log level of the stream handle back to INFO or DEBUG
-        if debugging:
-            self.stream_handler.setLevel(logging.DEBUG)
-        else:
-            self.stream_handler.setLevel(logging.INFO)
-        # Remove handler
-        self._logger.removeHandler(self.file_handler)
-
-    def enable_debugging(self):
-        logger = self.get_logger(__class__.__name__)
-        logger.info('Debug logging enabled')
-        self._logger.setLevel(logging.DEBUG)
-
-    def disable_debugging(self):
-        logger = self.get_logger(__class__.__name__)
-        logger.info('Debug logging disabled')
-        self._logger.setLevel(logging.INFO)
-
-    def setup_logger(self, settings):
-        logger = self.get_logger(__class__.__name__)
-        logger.info("Initialising file logger. All further logs should output to the 'unmanic.log' file")
-        # Set/Update our settings
-        self._settings = settings
-        if not self.file_handler:
-            self.setup_file_handler()
-        if self._settings.get_debugging():
-            self.enable_debugging()
-        else:
-            self.disable_debugging()
-
-    def get_logger(self, name=None):
-        if name:
-            logger = logging.getLogger("Unmanic." + name)
-        else:
-            logger = self._logger
-        return logger
diff --git a/unmanic/libs/unmodels/installation.py b/unmanic/libs/unmodels/installation.py
index 44bdb6b6..b34a2c81 100644
--- a/unmanic/libs/unmodels/installation.py
+++ b/unmanic/libs/unmodels/installation.py
@@ -53,4 +53,5 @@ class Installation(BaseModel):
     # Store session tokens
     user_access_token = TextField(null=True)
     user_refresh_token = TextField(null=True)
+    application_token = TextField(null=True)
     session_cookies = TextField(null=True)
diff --git a/unmanic/libs/unplugins/executor.py b/unmanic/libs/unplugins/executor.py
index 779fae61..4ad1cd1c 100644
--- a/unmanic/libs/unplugins/executor.py
+++ b/unmanic/libs/unplugins/executor.py
@@ -37,8 +37,8 @@
 import sys
 
 from . import plugin_types
-from unmanic.libs import unlogger, common
-from ..unmodels import LibraryPluginFlow
+from unmanic.libs import common
+from ..logs import UnmanicLogging
 
 
 class PluginExecutor(object):
@@ -77,12 +77,7 @@ def __init__(self, plugins_directory=None):
                 'has_flow': True,
             },
         ]
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
-
-    def _log(self, message, message2='', level="info"):
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def __get_plugin_directory(self, plugin_id):
         """
@@ -145,8 +140,7 @@ def __load_plugin_module(self, plugin_id, path):
 
             return plugin_import
         except Exception as e:
-            self._log("Exception encountered while importing module '{}'".format(plugin_id), message2=str(e),
-                      level="exception")
+            self.logger.exception("Exception encountered while importing module '%s'. %s", plugin_id, e)
             return None
 
     def reload_plugin_module(self, plugin_id):
@@ -158,7 +152,7 @@ def reload_plugin_module(self, plugin_id):
         """
         # Set the module name
         module_name = '{}.plugin'.format(plugin_id)
-        # self._log("Reloading module '{}'".format(module_name), level="debug")
+        # self.logger.debug("Reloading module '{}'".format(module_name))
 
         if module_name in sys.modules:
             # Get all submodules
@@ -175,8 +169,7 @@ def reload_plugin_module(self, plugin_id):
                     # The module's parent was probably not imported.
                     # Delete it from sys.modules and carry on.
                     # This will force it to be reloaded again
-                    self._log("Exception encountered while trying to reload module '{}'".format(module_name),
-                              level="exception")
+                    self.logger.exception("Exception encountered while trying to reload module '%s'", module_name)
                     del sys.modules[module_name]
 
     @staticmethod
@@ -256,8 +249,7 @@ def execute_plugin_runner(self, data, plugin_id, plugin_type):
                 runner(data)
                 run_successfully = True
             except Exception:
-                self._log("Exception while carrying out '{}' plugin runner '{}'".format(plugin_type, plugin_id),
-                          level="exception")
+                self.logger.exception("Exception while carrying out '%s' plugin runner '%s'", plugin_type, plugin_id)
 
             del runner
             # gc.collect()
@@ -280,7 +272,7 @@ def build_plugin_data_from_plugin_list_filtered_by_plugin_type(self, plugins_lis
 
         # Ensure called runner type exists
         if not plugin_type in plugin_types.get_all_plugin_types():
-            self._log("Provided plugin type does not exist!", plugin_type, level="error")
+            self.logger.error("Provided plugin type does not exist! %s", plugin_type)
             return plugin_modules
 
         # Get the called runner function for the given plugin type
@@ -364,7 +356,7 @@ def get_plugin_settings(self, plugin_id, library_id=None):
             all_plugin_settings = copy.deepcopy(plugin_settings.get_setting())
             plugin_form_settings = copy.deepcopy(plugin_settings.get_form_settings())
         except Exception as e:
-            self._log("Exception while fetching settings for plugin '{}'".format(plugin_id), str(e), level='exception')
+            self.logger.exception("Exception while fetching settings for plugin '%s' %s", plugin_id, e)
             all_plugin_settings = {}
             plugin_form_settings = {}
 
@@ -403,8 +395,7 @@ def save_plugin_settings(self, plugin_id, settings, library_id=None):
 
             return save_result
         except Exception as e:
-            self._log("Exception while saving settings for plugin '{}'".format(plugin_id), str(e), level='exception')
-            self._log(str(e), level='exception')
+            self.logger.exception("Exception while saving settings for plugin '%s' %s", plugin_id, e)
             return False
 
     def reset_plugin_settings(self, plugin_id, library_id=None):
@@ -425,7 +416,7 @@ def reset_plugin_settings(self, plugin_id, library_id=None):
             plugin_settings = plugin_module.Settings(library_id=library_id)
             return plugin_settings.reset_settings_to_defaults()
         except Exception as e:
-            self._log("Exception while resetting settings for plugin '{}'".format(plugin_id), str(e), level='exception')
+            self.logger.exception("Exception while resetting settings for plugin '%s' %s", plugin_id, e)
             return False
 
     def get_plugin_changelog(self, plugin_id):
@@ -481,8 +472,7 @@ def test_plugin_runner(self, plugin_id, plugin_type, test_data=None, test_data_m
                 test_data = plugin_type_meta.modify_test_data(test_data, test_data_modifiers)
             errors = plugin_type_meta.run_data_schema_tests(plugin_id, plugin_module, test_data=test_data)
         except Exception as e:
-            self._log("Exception while testing plugin runner for plugin '{}'".format(plugin_id), message2=str(e),
-                      level="exception")
+            self.logger.exception("Exception while testing plugin runner for plugin '%s' %s", plugin_id, e)
             errors = ["Exception encountered while testing runner - {}".format(str(e))]
 
         return errors
diff --git a/unmanic/libs/unplugins/pluginscli.py b/unmanic/libs/unplugins/pluginscli.py
index fc8765a4..b5267001 100644
--- a/unmanic/libs/unplugins/pluginscli.py
+++ b/unmanic/libs/unplugins/pluginscli.py
@@ -43,9 +43,10 @@
 from . import plugin_types
 
 from unmanic import config
-from unmanic.libs import unlogger, common
+from unmanic.libs import common
 from unmanic.libs.plugins import PluginsHandler
 from unmanic.libs.unplugins import PluginExecutor
+from ..logs import UnmanicLogging
 
 home_directory = common.get_home_dir()
 dev_cache_directory = os.path.join(home_directory, '.unmanic', 'dev', 'cache')
@@ -158,16 +159,16 @@ def __init__(self, plugins_directory=None):
             home_directory = common.get_home_dir()
             plugins_directory = os.path.join(home_directory, '.unmanic', 'plugins')
         self.plugins_directory = plugins_directory
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        unmanic_logging.disable_file_handler(debugging=True)
-        unmanic_logging.stream_handler.setFormatter(
+        # Only log to stdout
+        UnmanicLogging.update_stream_formatter(
             logging.Formatter(
                 '        - {}%(asctime)s:%(levelname)s:%(name)s - %(message)s{}'.format(BColours.RESULTS, BColours.ENDC),
                 datefmt='%Y-%m-%dT%H:%M:%S'
             )
         )
-        unmanic_logging.enable_debugging()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        UnmanicLogging.disable_file_handler(debugging=True)
+        UnmanicLogging.enable_debugging()
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
         self.test_data_modifiers = {
             "{cache_path}":    dev_cache_directory,
@@ -176,10 +177,6 @@ def __init__(self, plugins_directory=None):
             "{test_file_out}": "Big_Buck_Bunny_1080_10s_30MB_h264-1616571944.7296877-WORKING-1.mkv"
         }
 
-    def _log(self, message, message2='', level="info"):
-        message = common.format_message(message, message2)
-        getattr(self.logger, level)(message)
-
     def create_new_plugins(self):
         plugin_details = inquirer.prompt(menus.get('create_plugin'))
 
@@ -549,7 +546,7 @@ def main(self, arg):
         if function:
             getattr(self, function)()
         else:
-            self._log("Invalid selection")
+            self.logger.info("Invalid selection")
             return
 
     def run(self):
diff --git a/unmanic/libs/workers.py b/unmanic/libs/workers.py
index 80c8962a..c7f1c293 100644
--- a/unmanic/libs/workers.py
+++ b/unmanic/libs/workers.py
@@ -29,7 +29,6 @@
            OR OTHER DEALINGS IN THE SOFTWARE.
 
 """
-import hashlib
 import os
 import queue
 import shlex
@@ -40,7 +39,8 @@
 
 import psutil
 
-from unmanic.libs import common, unlogger
+from unmanic.libs import common
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.plugins import PluginsHandler
 
 
@@ -92,8 +92,7 @@ def __init__(self, thread_id, name, worker_group_id, pending_queue, complete_que
         self.paused_flag.clear()
 
         # Create logger for this worker
-        unmanic_logging = unlogger.UnmanicLogger.__call__()
-        self.logger = unmanic_logging.get_logger(self.name)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
 
     def _log(self, message, message2='', level="info"):
         message = common.format_message(message, message2)
@@ -461,8 +460,10 @@ def __exec_worker_runners_on_set_task(self):
         # Log if no command was run by any Plugins
         if no_exec_command_run:
             # If no jobs were carried out on this task
-            self._log("No Plugin requested for Unmanic to run commands for this file '{}'".format(original_abspath), level='warning')
-            self.worker_log.append("\n\nNo Plugin requested for Unmanic to run commands for this file '{}'".format(original_abspath))
+            self._log("No Plugin requested for Unmanic to run commands for this file '{}'".format(original_abspath),
+                      level='warning')
+            self.worker_log.append(
+                "\n\nNo Plugin requested for Unmanic to run commands for this file '{}'".format(original_abspath))
 
         # Save the completed command log
         self.current_task.save_command_log(self.worker_log)
diff --git a/unmanic/service.py b/unmanic/service.py
index 7d2d2e03..fccfbd03 100755
--- a/unmanic/service.py
+++ b/unmanic/service.py
@@ -37,8 +37,9 @@
 import threading
 
 from unmanic import config, metadata
-from unmanic.libs import libraryscanner, unlogger, common, eventmonitor
+from unmanic.libs import libraryscanner, common, eventmonitor
 from unmanic.libs.db_migrate import Migrations
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.scheduler import ScheduledTasksManager
 from unmanic.libs.taskqueue import TaskQueue
 from unmanic.libs.postprocessor import PostProcessor
@@ -46,9 +47,6 @@
 from unmanic.libs.uiserver import FrontendPushMessages, UIServer
 from unmanic.libs.foreman import Foreman
 
-unmanic_logging = unlogger.UnmanicLogger.__call__()
-main_logger = unmanic_logging.get_logger()
-
 
 def init_db(config_path):
     # Set paths
@@ -78,7 +76,7 @@ def init_db(config_path):
     return db_connection
 
 
-class Service:
+class RootService:
 
     def __init__(self):
         self.threads = []
@@ -88,10 +86,13 @@ def __init__(self):
         self.developer = None
         self.dev_api = None
 
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
+        UnmanicLogging.metric("Started")
+
         self.event = threading.Event()
 
     def start_handler(self, data_queues, task_queue):
-        main_logger.info("Starting TaskHandler")
+        self.logger.info("Starting TaskHandler")
         handler = TaskHandler(data_queues, task_queue, self.event)
         handler.daemon = True
         handler.start()
@@ -102,7 +103,7 @@ def start_handler(self, data_queues, task_queue):
         return handler
 
     def start_post_processor(self, data_queues, task_queue):
-        main_logger.info("Starting PostProcessor")
+        self.logger.info("Starting PostProcessor")
         postprocessor = PostProcessor(data_queues, task_queue, self.event)
         postprocessor.daemon = True
         postprocessor.start()
@@ -113,7 +114,7 @@ def start_post_processor(self, data_queues, task_queue):
         return postprocessor
 
     def start_foreman(self, data_queues, settings, task_queue):
-        main_logger.info("Starting Foreman")
+        self.logger.info("Starting Foreman")
         foreman = Foreman(data_queues, settings, task_queue, self.event)
         foreman.daemon = True
         foreman.start()
@@ -124,7 +125,7 @@ def start_foreman(self, data_queues, settings, task_queue):
         return foreman
 
     def start_library_scanner_manager(self, data_queues):
-        main_logger.info("Starting LibraryScannerManager")
+        self.logger.info("Starting LibraryScannerManager")
         library_scanner_manager = libraryscanner.LibraryScannerManager(data_queues, self.event)
         library_scanner_manager.daemon = True
         library_scanner_manager.start()
@@ -136,7 +137,7 @@ def start_library_scanner_manager(self, data_queues):
 
     def start_inotify_watch_manager(self, data_queues, settings):
         if eventmonitor.event_monitor_module:
-            main_logger.info("Starting EventMonitorManager")
+            self.logger.info("Starting EventMonitorManager")
             event_monitor_manager = eventmonitor.EventMonitorManager(data_queues, self.event)
             event_monitor_manager.daemon = True
             event_monitor_manager.start()
@@ -146,10 +147,10 @@ def start_inotify_watch_manager(self, data_queues, settings):
             })
             return event_monitor_manager
         else:
-            main_logger.warn("Unable to start EventMonitorManager as no event monitor module was found")
+            self.logger.warn("Unable to start EventMonitorManager as no event monitor module was found")
 
     def start_ui_server(self, data_queues, foreman):
-        main_logger.info("Starting UIServer")
+        self.logger.info("Starting UIServer")
         uiserver = UIServer(data_queues, foreman, self.developer)
         uiserver.daemon = True
         uiserver.start()
@@ -160,7 +161,7 @@ def start_ui_server(self, data_queues, foreman):
         return uiserver
 
     def start_scheduled_tasks_manager(self):
-        main_logger.info("Starting ScheduledTasksManager")
+        self.logger.info("Starting ScheduledTasksManager")
         scheduled_tasks_manager = ScheduledTasksManager(self.event)
         scheduled_tasks_manager.daemon = True
         scheduled_tasks_manager.start()
@@ -183,14 +184,13 @@ def start_threads(self, settings):
             "inotifytasks":             queue.Queue(),
             "progress_reports":         queue.Queue(),
             "frontend_messages":        FrontendPushMessages(),
-            "logging":                  unmanic_logging
         }
 
         # Clear cache directory
-        main_logger.info("Clearing previous cache")
+        self.logger.info("Clearing previous cache")
         common.clean_files_in_cache_dir(settings.get_cache_path())
 
-        main_logger.info("Starting all threads")
+        self.logger.info("Starting all threads")
 
         # Register installation
         self.initial_register_unmanic()
@@ -220,19 +220,19 @@ def start_threads(self, settings):
         self.start_scheduled_tasks_manager()
 
     def stop_threads(self):
-        main_logger.info("Stopping all threads")
+        self.logger.info("Stopping all threads")
         self.event.set()
         for thread in self.threads:
-            main_logger.info("Sending thread {} abort signal".format(thread['name']))
+            self.logger.info("Sending thread {} abort signal".format(thread['name']))
             thread['thread'].stop()
         for thread in self.threads:
-            main_logger.info("Waiting for thread {} to stop".format(thread['name']))
+            self.logger.info("Waiting for thread {} to stop".format(thread['name']))
             thread['thread'].join(10)
-            main_logger.info("Thread {} has successfully stopped".format(thread['name']))
+            self.logger.info("Thread {} has successfully stopped".format(thread['name']))
         self.threads = []
 
     def sig_handle(self, signum, frame):
-        main_logger.info("Received {}".format(signum))
+        self.logger.info("Received {}".format(signum))
         self.stop()
 
     def stop(self):
@@ -268,7 +268,7 @@ def run(self):
         while not self.db_connection.is_stopped():
             time.sleep(.5)
             continue
-        main_logger.info("Exit Unmanic")
+        self.logger.info("Exit Unmanic")
 
 
 def main():
@@ -310,7 +310,7 @@ def main():
             continue
     else:
         # Run the main Unmanic service
-        service = Service()
+        service = RootService()
         service.developer = args.dev
         service.dev_api = args.dev_api
         service.run()
diff --git a/unmanic/webserver/api_v2/schema/schemas.py b/unmanic/webserver/api_v2/schema/schemas.py
index 6c7aa006..ec728b11 100644
--- a/unmanic/webserver/api_v2/schema/schemas.py
+++ b/unmanic/webserver/api_v2/schema/schemas.py
@@ -1056,6 +1056,36 @@ class SessionStateSuccessSchema(BaseSchema):
     )
 
 
+class SessionAuthCodeSchema(BaseSchema):
+    """Schema for returning a verification auth code request"""
+
+    user_code = fields.Str(
+        required=True,
+        description="The user code",
+        example="123456",
+    )
+    device_code = fields.Str(
+        required=True,
+        description="A device code",
+        example="6f6867e0006f7240c9a85703a521f1705873630355f68ebbcf251a07b080172b",
+    )
+    verification_uri = fields.Str(
+        required=True,
+        description="The verification URI to submit the code manually",
+        example="/support-auth-api/link",
+    )
+    verification_uri_complete = fields.Str(
+        required=True,
+        description="User email",
+        example="/support-auth-api/v2/app_auth/link_with_user_code/123456",
+    )
+    expires_in = fields.Number(
+        required=True,
+        description="The time until the user_code expires",
+        example=120,
+    )
+
+
 # SETTINGS
 # ========
 
diff --git a/unmanic/webserver/api_v2/session_api.py b/unmanic/webserver/api_v2/session_api.py
index 7a64f8d4..c710579a 100644
--- a/unmanic/webserver/api_v2/session_api.py
+++ b/unmanic/webserver/api_v2/session_api.py
@@ -31,16 +31,19 @@
 """
 
 import tornado.log
+from tornado.ioloop import IOLoop
+
 from unmanic.libs import session
+from unmanic.libs.logs import UnmanicLogging
 from unmanic.libs.uiserver import UnmanicDataQueues
-from unmanic.service import unmanic_logging
 from unmanic.webserver.api_v2.base_api_handler import BaseApiHandler, BaseApiError
-from unmanic.webserver.api_v2.schema.schemas import SessionStateSuccessSchema
+from unmanic.webserver.api_v2.schema.schemas import SessionAuthCodeSchema, SessionStateSuccessSchema
 
 
 class ApiSessionHandler(BaseApiHandler):
     session = None
     config = None
+    logger = None
     params = None
     unmanic_data_queues = None
 
@@ -60,11 +63,16 @@ class ApiSessionHandler(BaseApiHandler):
             "supported_methods": ["GET"],
             "call_method":       "session_logout",
         },
+        {
+            "path_pattern":      r"/session/get_app_auth_code",
+            "supported_methods": ["GET"],
+            "call_method":       "get_app_auth_code",
+        },
     ]
 
     def initialize(self, **kwargs):
         self.session = session.Session()
-        self.logger = unmanic_logging.get_logger(__class__.__name__)
+        self.logger = UnmanicLogging.get_logger(name=__class__.__name__)
         self.params = kwargs.get("params")
         udq = UnmanicDataQueues()
         self.unmanic_data_queues = udq.get_unmanic_data_queues()
@@ -235,3 +243,84 @@ async def session_logout(self):
         except Exception as e:
             self.set_status(self.STATUS_ERROR_INTERNAL, reason=str(e))
             self.write_error()
+
+    async def get_app_auth_code(self):
+        """
+        Session - state
+        ---
+        description: Initiates the device authentication flow.
+        responses:
+            200:
+                description: 'Sample response: Initiates the device authentication flow.'
+                content:
+                    application/json:
+                        schema:
+                            SessionAuthCodeSchema
+            400:
+                description: Bad request; Check `messages` for any validation errors
+                content:
+                    application/json:
+                        schema:
+                            BadRequestSchema
+            404:
+                description: Bad request; Requested endpoint not found
+                content:
+                    application/json:
+                        schema:
+                            BadEndpointSchema
+            405:
+                description: Bad request; Requested method is not allowed
+                content:
+                    application/json:
+                        schema:
+                            BadMethodSchema
+            500:
+                description: Internal error; Check `error` for exception
+                content:
+                    application/json:
+                        schema:
+                            InternalErrorSchema
+        """
+        try:
+            current_loop = IOLoop.current()
+
+            # Run the synchronous init_device_auth_flow in a thread so we don't block the IOLoop.
+            device_auth_data = await current_loop.run_in_executor(None, self.session.init_device_auth_flow)
+            if not device_auth_data:
+                raise Exception("Failed to initiate device authentication flow.")
+
+            user_code = device_auth_data.get("user_code")
+            device_code = device_auth_data.get("device_code")
+            verification_uri = device_auth_data.get("verification_uri")
+            verification_uri_complete = device_auth_data.get("verification_uri_complete")
+            interval = device_auth_data.get("interval")
+            expires_in = device_auth_data.get("expires_in")
+
+            # Use the existing Tornado loop to run the blocking polling function in the background.
+            if self.session.token_poll_task is not None and not self.session.token_poll_task.done():
+                self.logger.info("Cancelling the running poll task and starting a new one.")
+                self.session.token_poll_task.cancel()
+            self.session.token_poll_task = current_loop.run_in_executor(
+                None,
+                self.session.poll_for_app_token,
+                device_code,
+                interval,
+                expires_in
+            )
+
+            response = self.build_response(
+                SessionAuthCodeSchema(),
+                {
+                    "user_code":                 user_code,
+                    "device_code":               device_code,
+                    "verification_uri":          verification_uri,
+                    "verification_uri_complete": verification_uri_complete,
+                    "expires_in":                expires_in,
+                }
+            )
+            self.write_success(response)
+            return
+
+        except Exception as e:
+            self.set_status(self.STATUS_ERROR_INTERNAL, reason=str(e))
+            self.write_error()
diff --git a/unmanic/webserver/docs/api_schema_v2.json b/unmanic/webserver/docs/api_schema_v2.json
index 0758e68b..cf7177ec 100644
--- a/unmanic/webserver/docs/api_schema_v2.json
+++ b/unmanic/webserver/docs/api_schema_v2.json
@@ -54,7 +54,8 @@
                             "name": [
                                 "The thing that went wrong."
                             ]
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "traceback": {
                         "type": "array",
@@ -115,7 +116,8 @@
                             "name": [
                                 "The thing that went wrong."
                             ]
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "traceback": {
                         "type": "array",
@@ -168,7 +170,8 @@
                             }
                         ],
                         "items": {
-                            "type": "object"
+                            "type": "object",
+                            "additionalProperties": {}
                         }
                     },
                     "files": {
@@ -186,7 +189,8 @@
                             }
                         ],
                         "items": {
-                            "type": "object"
+                            "type": "object",
+                            "additionalProperties": {}
                         }
                     }
                 },
@@ -450,7 +454,8 @@
                         "description": "The navigation links of the notification",
                         "example": {
                             "url": "https://docs.unmanic.app"
-                        }
+                        },
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -979,7 +984,8 @@
                             }
                         ],
                         "items": {
-                            "type": "object"
+                            "type": "object",
+                            "additionalProperties": {}
                         }
                     },
                     "slider_options": {
@@ -989,7 +995,8 @@
                             "min": 1,
                             "max": 8,
                             "suffix": "M"
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "display": {
                         "type": "string",
@@ -1482,6 +1489,43 @@
                     "uuid"
                 ]
             },
+            "SessionAuthCode": {
+                "type": "object",
+                "properties": {
+                    "user_code": {
+                        "type": "string",
+                        "description": "The user code",
+                        "example": "123456"
+                    },
+                    "device_code": {
+                        "type": "string",
+                        "description": "A device code",
+                        "example": "6f6867e0006f7240c9a85703a521f1705873630355f68ebbcf251a07b080172b"
+                    },
+                    "verification_uri": {
+                        "type": "string",
+                        "description": "The verification URI to submit the code manually",
+                        "example": "/support-auth-api/link"
+                    },
+                    "verification_uri_complete": {
+                        "type": "string",
+                        "description": "User email",
+                        "example": "/support-auth-api/v2/app_auth/link_with_user_code/123456"
+                    },
+                    "expires_in": {
+                        "type": "number",
+                        "description": "The time until the user_code expires",
+                        "example": 120
+                    }
+                },
+                "required": [
+                    "device_code",
+                    "expires_in",
+                    "user_code",
+                    "verification_uri",
+                    "verification_uri_complete"
+                ]
+            },
             "SettingsReadAndWrite": {
                 "type": "object",
                 "properties": {
@@ -1497,7 +1541,8 @@
                             "follow_symlinks": true,
                             "run_full_scan_on_start": false,
                             "cache_path": "/tmp/unmanic"
-                        }
+                        },
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -1510,7 +1555,8 @@
                     "configuration": {
                         "type": "object",
                         "description": "The current system configuration",
-                        "example": {}
+                        "example": {},
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -1554,7 +1600,8 @@
                     "installation": {
                         "type": "object",
                         "description": "The data from the remote installation",
-                        "example": {}
+                        "example": {},
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -1708,7 +1755,8 @@
                             "preloading_count": 2,
                             "enable_checksum_validation": false,
                             "enable_config_missing_libraries": false
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "distributed_worker_count_target": {
                         "type": "integer",
@@ -1824,7 +1872,8 @@
                             "enable_inotify": false,
                             "priority_score": 0,
                             "tags": []
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "plugins": {
                         "type": "object",
@@ -1839,7 +1888,8 @@
                                     "icon": "https://raw.githubusercontent.com/Josh5/unmanic.plugin.notify_plex/master/icon.png"
                                 }
                             ]
-                        }
+                        },
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -1886,7 +1936,8 @@
                                 "postprocessor.file_move": [],
                                 "postprocessor.task_result": []
                             }
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "library_config": {
                         "type": "object",
@@ -1899,7 +1950,8 @@
                             "enable_inotify": false,
                             "priority_score": 0,
                             "tags": []
-                        }
+                        },
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -1946,7 +1998,8 @@
                                 "postprocessor.file_move": [],
                                 "postprocessor.task_result": []
                             }
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "library_config": {
                         "type": "object",
@@ -1959,7 +2012,8 @@
                             "enable_inotify": false,
                             "priority_score": 0,
                             "tags": []
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "library_id": {
                         "type": "integer",
@@ -2064,7 +2118,8 @@
                                 "description": "Remux a video file to the configured container",
                                 "success": true
                             }
-                        }
+                        },
+                        "additionalProperties": {}
                     },
                     "subprocess": {
                         "type": "object",
@@ -2073,7 +2128,8 @@
                             "pid": 140408939493120,
                             "percent": "None",
                             "elapsed": "None"
-                        }
+                        },
+                        "additionalProperties": {}
                     }
                 },
                 "required": [
@@ -4608,6 +4664,63 @@
                 }
             }
         },
+        "/session/get_app_auth_code": {
+            "get": {
+                "description": "Initiates the device authentication flow.",
+                "responses": {
+                    "200": {
+                        "description": "Sample response: Initiates the device authentication flow.",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/SessionAuthCode"
+                                }
+                            }
+                        }
+                    },
+                    "400": {
+                        "description": "Bad request; Check `messages` for any validation errors",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/BadRequest"
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        "description": "Bad request; Requested endpoint not found",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/BadEndpoint"
+                                }
+                            }
+                        }
+                    },
+                    "405": {
+                        "description": "Bad request; Requested method is not allowed",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/BadMethod"
+                                }
+                            }
+                        }
+                    },
+                    "500": {
+                        "description": "Internal error; Check `error` for exception",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/InternalError"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "/settings/read": {
             "get": {
                 "description": "Returns the application settings.",
diff --git a/unmanic/webserver/docs/api_schema_v2.yaml b/unmanic/webserver/docs/api_schema_v2.yaml
index 9f46312e..45f82abd 100644
--- a/unmanic/webserver/docs/api_schema_v2.yaml
+++ b/unmanic/webserver/docs/api_schema_v2.yaml
@@ -45,6 +45,7 @@ components:
           example: &id001
             name:
             - The thing that went wrong.
+          additionalProperties: {}
         traceback:
           type: array
           description: Attached exception traceback (if developer mode is enabled)
@@ -91,6 +92,7 @@ components:
           type: object
           description: Attached request body validation errors
           example: *id001
+          additionalProperties: {}
         traceback:
           type: array
           description: Attached exception traceback (if developer mode is enabled)
@@ -125,6 +127,7 @@ components:
             label: /tmp
           items:
             type: object
+            additionalProperties: {}
         files:
           type: array
           minItems: 0
@@ -136,6 +139,7 @@ components:
             label: /file2.txt
           items:
             type: object
+            additionalProperties: {}
       required:
       - directories
       - files
@@ -336,6 +340,7 @@ components:
           description: The navigation links of the notification
           example:
             url: https://docs.unmanic.app
+          additionalProperties: {}
       required:
       - icon
       - label
@@ -742,6 +747,7 @@ components:
             label: Second Option
           items:
             type: object
+            additionalProperties: {}
         slider_options:
           type: object
           description: Additional options if the input_type is set to 'slider'
@@ -749,6 +755,7 @@ components:
             min: 1
             max: 8
             suffix: M
+          additionalProperties: {}
         display:
           type: string
           description: Should the setting input be displayed (visible, hidden)
@@ -1119,6 +1126,35 @@ components:
       required:
       - level
       - uuid
+    SessionAuthCode:
+      type: object
+      properties:
+        user_code:
+          type: string
+          description: The user code
+          example: '123456'
+        device_code:
+          type: string
+          description: A device code
+          example: 6f6867e0006f7240c9a85703a521f1705873630355f68ebbcf251a07b080172b
+        verification_uri:
+          type: string
+          description: The verification URI to submit the code manually
+          example: /support-auth-api/link
+        verification_uri_complete:
+          type: string
+          description: User email
+          example: /support-auth-api/v2/app_auth/link_with_user_code/123456
+        expires_in:
+          type: number
+          description: The time until the user_code expires
+          example: 120
+      required:
+      - device_code
+      - expires_in
+      - user_code
+      - verification_uri
+      - verification_uri_complete
     SettingsReadAndWrite:
       type: object
       properties:
@@ -1134,6 +1170,7 @@ components:
             follow_symlinks: true
             run_full_scan_on_start: false
             cache_path: /tmp/unmanic
+          additionalProperties: {}
       required:
       - settings
     SettingsSystemConfig:
@@ -1143,6 +1180,7 @@ components:
           type: object
           description: The current system configuration
           example: {}
+          additionalProperties: {}
       required:
       - configuration
     RequestSettingsRemoteInstallationAddressValidation:
@@ -1176,6 +1214,7 @@ components:
           type: object
           description: The data from the remote installation
           example: {}
+          additionalProperties: {}
       required:
       - installation
     WorkerEventScheduleResults:
@@ -1293,6 +1332,7 @@ components:
             preloading_count: 2
             enable_checksum_validation: false
             enable_config_missing_libraries: false
+          additionalProperties: {}
         distributed_worker_count_target:
           type: integer
           description: The target count of workers to be distributed across any configured
@@ -1382,6 +1422,7 @@ components:
             enable_inotify: false
             priority_score: 0
             tags: []
+          additionalProperties: {}
         plugins:
           type: object
           description: The library's enabled plugins
@@ -1392,6 +1433,7 @@ components:
               name: Notify Plex
               description: Notify Plex on completion of a task.
               icon: https://raw.githubusercontent.com/Josh5/unmanic.plugin.notify_plex/master/icon.png
+          additionalProperties: {}
       required:
       - library_config
     SettingsLibraryPluginConfigExport:
@@ -1427,6 +1469,7 @@ components:
                 icon: https://raw.githubusercontent.com/Josh5/unmanic.plugin.encoder_audio_ac3/master/icon.png
               postprocessor.file_move: []
               postprocessor.task_result: []
+          additionalProperties: {}
         library_config:
           type: object
           description: The library configuration
@@ -1438,6 +1481,7 @@ components:
             enable_inotify: false
             priority_score: 0
             tags: []
+          additionalProperties: {}
       required:
       - plugins
     SettingsLibraryPluginConfigImport:
@@ -1447,10 +1491,12 @@ components:
           type: object
           description: The library's enabled plugins
           example: *id004
+          additionalProperties: {}
         library_config:
           type: object
           description: The library configuration
           example: *id005
+          additionalProperties: {}
         library_id:
           type: integer
           example: 1
@@ -1538,6 +1584,7 @@ components:
               icon: https://raw.githubusercontent.com/Josh5/unmanic.plugin.video_remuxer/master/icon.png
               description: Remux a video file to the configured container
               success: true
+          additionalProperties: {}
         subprocess:
           type: object
           description: The status of the process currently being executed
@@ -1545,6 +1592,7 @@ components:
             pid: 140408939493120
             percent: None
             elapsed: None
+          additionalProperties: {}
       required:
       - current_file
       - current_task
@@ -3080,6 +3128,40 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/InternalError'
+  /session/get_app_auth_code:
+    get:
+      description: Initiates the device authentication flow.
+      responses:
+        '200':
+          description: 'Sample response: Initiates the device authentication flow.'
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SessionAuthCode'
+        '400':
+          description: Bad request; Check `messages` for any validation errors
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/BadRequest'
+        '404':
+          description: Bad request; Requested endpoint not found
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/BadEndpoint'
+        '405':
+          description: Bad request; Requested method is not allowed
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/BadMethod'
+        '500':
+          description: Internal error; Check `error` for exception
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/InternalError'
   /settings/read:
     get:
       description: Returns the application settings.
diff --git a/unmanic/webserver/frontend b/unmanic/webserver/frontend
index df4e9894..e7289da7 160000
--- a/unmanic/webserver/frontend
+++ b/unmanic/webserver/frontend
@@ -1 +1 @@
-Subproject commit df4e98949881c4e383e7b2474af59cba730be1e5
+Subproject commit e7289da79dc61ba91d66b1f07cfd149763e45a7e