[Dexter] Add a simple logging class to Dexter

[StephenTozer]

Summary

Adds a basic logging class to Dexter that uses the existing PrettyOutput class for printing and supports 3 levels of verbosity (note, warning, error). Intended to consolidate the logic for Dexter into one place, removing the need for conditional log statements and making it easier for us later if we wish to use a more complete logging class.

[Orlando]

Did you intend to add the new prints (e.g. VS: Using executable: '{exe_path}') in this patch? Either way LGTM.

cross-project-tests/debuginfo-tests/dexter/dex/debugger/Debuggers.py

 import sys
 from tempfile import NamedTemporaryFile
 
 from dex.command import get_command_infos
 from dex.dextIR import DextIR
 from dex.utils import get_root_directory, Timer
 from dex.utils.Environment import is_native_windows
 from dex.utils.Exceptions import ToolArgumentError
-from dex.utils.Warning import warn
 from dex.utils.Exceptions import DebuggerException
 
 from dex.debugger.DebuggerControllers.DefaultController import DefaultController
 
 from dex.debugger.dbgeng.dbgeng import DbgEng
 from dex.debugger.lldb.LLDB import LLDB
 from dex.debugger.visualstudio.VisualStudio2015 import VisualStudio2015
 from dex.debugger.visualstudio.VisualStudio2017 import VisualStudio2017
return {
         VisualStudio2019.get_option_name(): VisualStudio2019
     }
 
 
 def _warn_meaningless_option(context, option):
     if hasattr(context.options, 'list_debuggers'):
         return
 
-    warn(context,
-         'option <y>"{}"</> is meaningless with this debugger'.format(option),
-         '--debugger={}'.format(context.options.debugger))
+    context.logger.warning(
+         f'option "{option}" is meaningless with this debugger',
+         enable_prefix=True,
+         flag=f'--debugger={context.options.debugger}')
 
 
 def add_debugger_tool_base_arguments(parser, defaults):
     defaults.lldb_executable = 'lldb.exe' if is_native_windows() else 'lldb'
     parser.add_argument(
         '--lldb-executable',
         type=str,
         metavar='<file>',

cross-project-tests/debuginfo-tests/dexter/dex/debugger/visualstudio/VisualStudio.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """Interface for communicating with the Visual Studio debugger via DTE."""
 
 import abc
 import imp
 import os
 import sys
-from pathlib import PurePath
+from pathlib import PurePath, Path
 from collections import defaultdict, namedtuple
 
 from dex.command.CommandBase import StepExpectInfo
 from dex.debugger.DebuggerBase import DebuggerBase, watch_is_active
 from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR
 from dex.dextIR import StackFrame, SourceLocation, ProgramState
 from dex.utils.Exceptions import Error, LoadDebuggerException
 from dex.utils.ReturnCode import ReturnCode
def _fetch_property(self, props, name):
         result = None
         for x in range(1, num_props+1):
             item = props.Item(x)
             if item.Name == name:
                 return item
         assert False, "Couldn't find property {}".format(name)
 
     def launch(self, cmdline):
+        exe_path = Path(self.context.options.executable)
+        self.context.logger.note(f"VS: Using executable: '{exe_path}'")
         cmdline_str = ' '.join(cmdline)
         if self.context.options.target_run_args:
           cmdline_str += f" {self.context.options.target_run_args}"
+        if cmdline_str:
+          self.context.logger.note(f"VS: Using executable args: '{cmdline_str}'")
 
         # In a slightly baroque manner, lookup the VS project that runs when
         # you click "run", and set its command line options to the desired
         # command line options.
         startup_proj_name = str(self._fetch_property(self._interface.Solution.Properties, 'StartupProject'))
         project = self._fetch_property(self._interface.Solution, startup_proj_name)
         ActiveConfiguration = self._fetch_property(project.Properties, 'ActiveConfiguration').Object
         ActiveConfiguration.DebugSettings.CommandArguments = cmdline_str
 
+        self.context.logger.note("Launching VS debugger...")
         self._fn_go(False)
 
     def step(self):
         self._fn_step(False)
 
     def go(self) -> ReturnCode:
         self._fn_go(False)
         return ReturnCode.OK

cross-project-tests/debuginfo-tests/dexter/dex/tools/Main.py

 import imp
 import os
 import sys
 
 from dex.utils import PrettyOutput, Timer
 from dex.utils import ExtArgParse as argparse
 from dex.utils import get_root_directory
 from dex.utils.Exceptions import Error, ToolArgumentError
+from dex.utils.Logging import Logger
 from dex.utils.UnitTests import unit_tests_ok
 from dex.utils.Version import version
 from dex.utils import WorkingDirectory
 from dex.utils.ReturnCode import ReturnCode
 
 
 def _output_bug_report_message(context):
     """ In the event of a catastrophic failure, print bug report request to the
with Timer(tool.name):
         Timer.fn = context.o.blue
         context.options = options
         context.version = version(tool.name)
 
         if options.version:
             context.o.green('{}\n'.format(context.version))
             return ReturnCode.OK
 
+        if options.verbose:
+            context.logger.verbosity = 2
+        elif options.no_warnings:
+            context.logger.verbosity = 0
+
         if (options.unittest != 'off' and not unit_tests_ok(context)):
             raise Error('<d>unit test failures</>')
 
         if options.colortest:
             context.o.colortest()
             return ReturnCode.OK
 
         try:

 
 class Context(object):
     """Context encapsulates globally useful objects and data; passed to many
     Dexter functions.
     """
 
     def __init__(self):
         self.o: PrettyOutput = None
+        self.logger: Logger = None
         self.working_directory: str = None
         self.options: dict = None
         self.version: str = None
         self.root_directory: str = None
 
 
 def main() -> ReturnCode:
 
     context = Context()
 
     with PrettyOutput() as context.o:
+        context.logger = Logger(context.o)
         try:
             context.root_directory = get_root_directory()
             # Flag some strings for auto-highlighting.
             _set_auto_highlights(context)
             options, args = _get_options_and_args(context)
             # raises 'Error' if command line tool is invalid.
             tool_name = _get_tool_name(options)
             module = _import_tool_module(tool_name)
             return tool_main(context, module.Tool(context), args)
         except Error as e:
-            context.o.auto(
-                '\nerror: {}\n'.format(str(e)), stream=PrettyOutput.stderr)
+            context.logger.error(str(e))
             try:
                 if context.options.error_debug:
                     raise
             except AttributeError:
                 pass
             return ReturnCode._ERROR
         except (KeyboardInterrupt, SystemExit):
             raise
         except:  # noqa
             _output_bug_report_message(context)
             raise

cross-project-tests/debuginfo-tests/dexter/dex/tools/TestToolBase.py

 import sys
 
 from dex.builder import add_builder_tool_arguments
 from dex.builder import handle_builder_tool_options
 from dex.debugger.Debuggers import add_debugger_tool_arguments
 from dex.debugger.Debuggers import handle_debugger_tool_options
 from dex.heuristic.Heuristic import add_heuristic_tool_arguments
 from dex.tools.ToolBase import ToolBase
-from dex.utils import get_root_directory, warn
+from dex.utils import get_root_directory
 from dex.utils.Exceptions import Error, ToolArgumentError
 from dex.utils.ReturnCode import ReturnCode
 
 
 class TestToolBase(ToolBase):
     def __init__(self, *args, **kwargs):
         super(TestToolBase, self).__init__(*args, **kwargs)
         self.build_script: str = None
def add_tool_arguments(self, parser, defaults):
             metavar='<directory>',
             default=None,
             help='directory to save results (default: none)')
 
     def handle_options(self, defaults):
         options = self.context.options
 
         if not options.builder and (options.cflags or options.ldflags):
-            warn(self.context, '--cflags and --ldflags will be ignored when not'
-                               ' using --builder')
+            self.context.logger.warning(
+                '--cflags and --ldflags will be ignored when not using --builder',
+                enable_prefix=True)
 
         if options.vs_solution:
             options.vs_solution = os.path.abspath(options.vs_solution)
             if not os.path.isfile(options.vs_solution):
                 raise Error('<d>could not find VS solution file</> <r>"{}"</>'
                             .format(options.vs_solution))
         elif options.binary:
             options.binary = os.path.abspath(options.binary)

cross-project-tests/debuginfo-tests/dexter/dex/tools/ToolBase.py

def parse_command_line(self, args):
 
         self.parser = ExtArgParse.ExtArgumentParser(
             self.context, parents=[pparser], prog=self.name)
         self.parser.add_argument(
             '-v',
             '--verbose',
             action='store_true',
             default=False,
-            help='enable verbose output')
+            help='enable verbose output (overrides --no-warnings)')
         self.parser.add_argument(
             '-V',
             '--version',
             action='store_true',
             default=False,
             help='display the DExTer version and exit')
         self.parser.add_argument(
             '-w',

cross-project-tests/debuginfo-tests/dexter/dex/utils/Logging.py

+# DExTer : Debugging Experience Tester
+# ~~~~~~   ~         ~~         ~   ~~
+#
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+"""Utility functions for producing command line warnings."""
+
+from dex.utils import PrettyOutput
+
+class Logger(object):
+    def __init__(self, pretty_output: PrettyOutput):
+        self.o = pretty_output
+        self.error_color = self.o.red
+        self.warning_color = self.o.yellow
+        self.note_color = self.o.default
+        self.verbosity = 1
+
+    def error(self, msg, enable_prefix=True, flag=None):
+        if self.verbosity < 0:
+            return
+        if enable_prefix:
+            msg = f'error: {msg}'
+        if flag:
+           msg = f'{msg} <y>[{flag}]</>'
+        self.error_color('{}\n'.format(msg), stream=PrettyOutput.stderr)
+
+    def warning(self, msg, enable_prefix=True, flag=None):
+        if self.verbosity < 1:
+            return
+        if enable_prefix:
+            msg = f'warning: {msg}'
+        if flag:
+           msg = f'{msg} <y>[{flag}]</>'
+        self.warning_color('{}\n'.format(msg), stream=PrettyOutput.stderr)
+
+    def note(self, msg, enable_prefix=True, flag=None):
+        if self.verbosity < 2:
+            return
+        if enable_prefix:
+            msg = f'note: {msg}'
+        if flag:
+           msg = f'{msg} <y>[{flag}]</>'
+        self.note_color('{}\n'.format(msg), stream=PrettyOutput.stderr)

cross-project-tests/debuginfo-tests/dexter/dex/utils/Warning.py

-# DExTer : Debugging Experience Tester
-# ~~~~~~   ~         ~~         ~   ~~
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-"""Utility functions for producing command line warnings."""
-
-
-def warn(context, msg, flag=None):
-    if context.options.no_warnings:
-        return
-
-    msg = msg.rstrip()
-    if flag:
-        msg = '{} <y>[{}]</>'.format(msg, flag)
-
-    context.o.auto('warning: <d>{}</>\n'.format(msg))

cross-project-tests/debuginfo-tests/dexter/dex/utils/WorkingDirectory.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """Create/set a temporary working directory for some operations."""
 
 import os
 import shutil
 import tempfile
 import time
 
 from dex.utils.Exceptions import Error
-from dex.utils.Warning import warn
 
 class WorkingDirectory(object):
     def __init__(self, context, *args, **kwargs):
         self.context = context
         self.orig_cwd = os.getcwd()
 
         dir_ = kwargs.get('dir', None)
         if dir_ and not os.path.isdir(dir_):
def __exit__(self, *args):
 
         for _ in range(100):
             try:
                 shutil.rmtree(self.path)
                 return
             except OSError:
                 time.sleep(0.1)
 
-        warn(self.context, '"{}" left in place (couldn\'t delete)\n'.format(self.path))
+        self.context.logger.warning(f'"{self.path}" left in place (couldn\'t delete)', enable_prefix=True)
         return

cross-project-tests/debuginfo-tests/dexter/dex/utils/__init__.py

 # DExTer : Debugging Experience Tester
 # ~~~~~~   ~         ~~         ~   ~~
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """Generic non-dexter-specific utility classes and functions."""
 
 import os
 
 from dex.utils.Environment import is_native_windows, has_pywin32
 from dex.utils.PrettyOutputBase import PreserveAutoColors
 from dex.utils.RootDirectory import get_root_directory
 from dex.utils.Timer import Timer
-from dex.utils.Warning import warn
 from dex.utils.WorkingDirectory import WorkingDirectory
 
 if is_native_windows():
     from dex.utils.windows.PrettyOutput import PrettyOutput
 else:
     from dex.utils.posix.PrettyOutput import PrettyOutput
+
+from dex.utils.Logging import Logger