Standardise logging for script, plugin and service endpoints

resources/lib/youtube_plugin/kodion/plugin_runner.py

@@ -10,8 +10,6 @@
 
 from __future__ import absolute_import, division, unicode_literals
 
-from platform import python_version
-
 from .context import XbmcContext
 from .plugin import XbmcPlugin
 from ..youtube import Provider
@@ -24,6 +22,7 @@
 _provider = Provider()
 
 _profiler = _context.get_infobool('System.GetBool(debug.showloginfo)')
+_profiler = True
 if _profiler:
     from .debug import Profiler
 
@@ -37,8 +36,6 @@ def run(context=_context,
     if profiler:
         profiler.enable(flush=True)
 
-    context.log_debug('Starting Kodion framework by bromix...')
-
     current_uri = context.get_uri()
     context.init()
     new_uri = context.get_uri()
@@ -48,14 +45,15 @@ def run(context=_context,
         if key in params:
             params[key] = '<redacted>'
 
-    context.log_notice('Running: {plugin} ({version})'
-                       ' on {kodi} with Python {python}\n'
-                       'Path: {path}\n'
-                       'Params: {params}'
-                       .format(plugin=context.get_name(),
-                               version=context.get_version(),
-                               kodi=context.get_system_version(),
-                               python=python_version(),
+    system_version = context.get_system_version()
+    context.log_notice('Plugin: Running |v{version}|\n'
+                       'Kodi: |v{kodi}|\n'
+                       'Python: |v{python}|\n'
+                       'Path: |{path}|\n'
+                       'Params: |{params}|'
+                       .format(version=context.get_version(),
+                               kodi=str(system_version),
+                               python=system_version.get_python_version(),
                                path=context.get_path(),
                                params=params))
 

resources/lib/youtube_plugin/kodion/script_actions.py

@@ -646,6 +646,20 @@ def run(argv):
             if params:
                 params = dict(parse_qsl(args.query))
 
+        system_version = context.get_system_version()
+        context.log_notice('Script: Running |v{version}|\n'
+                           'Kodi: |v{kodi}|\n'
+                           'Python: |v{python}|\n'
+                           'Category: |{category}|\n'
+                           'Action: |{action}|\n'
+                           'Params: |{params}|'
+                           .format(version=context.get_version(),
+                                   kodi=str(system_version),
+                                   python=system_version.get_python_version(),
+                                   category=category,
+                                   action=action,
+                                   params=params))
+
         if not category:
             xbmcaddon.Addon().openSettings()
             return

resources/lib/youtube_plugin/kodion/service_runner.py

@@ -28,10 +28,16 @@
 
 def run():
     context = XbmcContext()
-    context.log_debug('YouTube service initialization...')
-
     provider = Provider()
 
+    system_version = context.get_system_version()
+    context.log_notice('Service: Starting |v{version}|\n'
+                       'Kodi: |v{kodi}|\n'
+                       'Python: |v{python}|'
+                       .format(version=context.get_version(),
+                               kodi=str(system_version),
+                               python=system_version.get_python_version()))
+
     get_listitem_info = context.get_listitem_info
     get_listitem_property = context.get_listitem_property
 

resources/lib/youtube_plugin/kodion/utils/system_version.py

@@ -10,70 +10,69 @@
 
 from __future__ import absolute_import, division, unicode_literals
 
+from platform import python_version
+
 from .methods import jsonrpc
 from ..compatibility import string_type
 
 
 class SystemVersion(object):
-    def __init__(self, version=None, releasename=None, appname=None):
-        self._version = (
-            version if version and isinstance(version, tuple)
-            else (0, 0, 0, 0)
-        )
+    RELEASE_MAP = {
+        (22, 0): 'Piers',
+        (21, 0): 'Omega',
+        (20, 0): 'Nexus',
+        (19, 0): 'Matrix',
+        (18, 0): 'Leia',
+        (17, 0): 'Krypton',
+        (16, 0): 'Jarvis',
+        (15, 0): 'Isengard',
+        (14, 0): 'Helix',
+        (13, 0): 'Gotham',
+        (12, 0): 'Frodo',
+    }
 
-        self._releasename = (
-            releasename if releasename and isinstance(releasename, string_type)
-            else 'UNKNOWN'
-        )
-
-        self._appname = (
-            appname if appname and isinstance(appname, string_type)
-            else 'UNKNOWN'
-        )
+    def __init__(self, version=None, releasename=None, appname=None):
+        if isinstance(version, tuple):
+            self._version = version
+        else:
+            version = None
 
-        try:
-            response = jsonrpc(method='Application.GetProperties',
-                               params={'properties': ['version', 'name']})
-            version_installed = response['result']['version']
-            self._version = (version_installed.get('major', 1),
-                             version_installed.get('minor', 0))
-            self._appname = response['result']['name']
-        except (KeyError, TypeError):
-            self._version = (1, 0)  # Frodo
-            self._appname = 'Unknown Application'
-
-        if self._version >= (22, 0):
-            self._releasename = 'Piers'
-        elif self._version >= (21, 0):
-            self._releasename = 'Omega'
-        elif self._version >= (20, 0):
-            self._releasename = 'Nexus'
-        elif self._version >= (19, 0):
-            self._releasename = 'Matrix'
-        elif self._version >= (18, 0):
-            self._releasename = 'Leia'
-        elif self._version >= (17, 0):
-            self._releasename = 'Krypton'
-        elif self._version >= (16, 0):
-            self._releasename = 'Jarvis'
-        elif self._version >= (15, 0):
-            self._releasename = 'Isengard'
-        elif self._version >= (14, 0):
-            self._releasename = 'Helix'
-        elif self._version >= (13, 0):
-            self._releasename = 'Gotham'
-        elif self._version >= (12, 0):
-            self._releasename = 'Frodo'
+        if appname and isinstance(appname, string_type):
+            self._appname = appname
+        else:
+            appname = None
+
+        if version is None or appname is None:
+            try:
+                result = jsonrpc(
+                    method='Application.GetProperties',
+                    params={'properties': ['version', 'name']},
+                )['result'] or {}
+            except (KeyError, TypeError):
+                result = {}
+
+            if version is None:
+                version = result.get('version') or {}
+                self._version = (version.get('major', 1),
+                                 version.get('minor', 0))
+
+            if appname is None:
+                self._appname = result.get('name', 'Unknown application')
+
+        if releasename and isinstance(releasename, string_type):
+            self._releasename = releasename
         else:
-            self._releasename = 'Unknown Release'
+            version = (self._version[0], self._version[1])
+            self._releasename = self.RELEASE_MAP.get(version, 'Unknown release')
+
+        self._python_version = python_version()
 
     def __str__(self):
-        obj_str = '{releasename} ({appname}-{version[0]}.{version[1]})'.format(
+        return '{version[0]}.{version[1]} ({appname} {releasename})'.format(
             releasename=self._releasename,
             appname=self._appname,
             version=self._version
         )
-        return obj_str
 
     def get_release_name(self):
         return self._releasename
@@ -84,6 +83,9 @@ def get_version(self):
     def get_app_name(self):
         return self._appname
 
+    def get_python_version(self):
+        return self._python_version
+
     def compatible(self, *version):
         return self._version >= version