Deal with callsites in Main

core/dbt/events/types.py

@@ -1,4 +1,5 @@
 from abc import ABCMeta, abstractmethod
+import argparse
 from dataclasses import dataclass
 from typing import Any, List, Optional, Dict
 from dbt import ui
@@ -68,6 +69,51 @@ def cli_msg(self) -> str:
  raise Exception("cli_msg not implemented for cli event")
 
 
+class MainKeyboardInterrupt(InfoLevel, CliEventABC):
+ def cli_msg(self) -> str:
+ return "ctrl-c"
+
+
+@dataclass
+class MainEncounteredError(ErrorLevel, CliEventABC):
+ e: BaseException
+
+ def cli_msg(self) -> str:
+ return f"Encountered an error:\n{str(self.e)}"
+
+
+@dataclass
+class MainStackTrace(DebugLevel, CliEventABC):
+ stack_trace: str
+
+ def cli_msg(self) -> str:
+ return self.stack_trace
+
+
+@dataclass
+class MainReportVersion(InfoLevel, CliEventABC):
+ v: str # could be VersionSpecifier instead if we resolved some circular imports
+
+ def cli_msg(self):
+ return f"Running with dbt{self.v}"
+
+
+@dataclass
+class MainReportArgs(DebugLevel, CliEventABC):
+ args: argparse.Namespace
+
+ def cli_msg(self):
+ return f"running dbt with arguments {str(self.args)}"
+
+
+@dataclass
+class MainTrackingUserState(DebugLevel, CliEventABC):
+ user_state: str
+
+ def cli_msg(self):
+ return f"Tracking: {self.user_state}"
+
+
 class ParsingStart(InfoLevel, CliEventABC):
  def cli_msg(self) -> str:
  return "Start parsing."
@@ -1728,6 +1774,12 @@ def cli_msg(self) -> str:
 #
 # TODO remove these lines once we run mypy everywhere.
 if 1 == 0:
+ MainReportVersion('')
+ MainKeyboardInterrupt()
+ MainEncounteredError(BaseException(''))
+ MainStackTrace('')
+ MainReportVersion('')
+ MainTrackingUserState('')
  ParsingStart()
  ParsingCompiling()
  ParsingWritingManifest()

core/dbt/main.py

@@ -1,5 +1,5 @@
 from typing import List
-from dbt.logger import GLOBAL_LOGGER as logger, log_cache_events, log_manager
+from dbt.logger import log_cache_events, log_manager
 
 import argparse
 import os.path
@@ -9,6 +9,11 @@
 from pathlib import Path
 
 import dbt.version
+from dbt.events.functions import fire_event
+from dbt.events.types import (
+ MainEncounteredError, MainKeyboardInterrupt, MainReportVersion, MainReportArgs,
+ MainTrackingUserState, MainStackTrace
+)
 import dbt.flags as flags
 import dbt.task.build as build_task
 import dbt.task.clean as clean_task
@@ -34,7 +39,6 @@
 from dbt.utils import ExitCodes
 from dbt.config.profile import DEFAULT_PROFILES_DIR, read_user_config
 from dbt.exceptions import (
- RuntimeException,
  InternalException,
  NotImplementedException,
  FailedToConnectException
@@ -127,24 +131,17 @@ def main(args=None):
  exit_code = ExitCodes.ModelError.value
 
  except KeyboardInterrupt:
- logger.info("ctrl-c")
+ # if the logger isn't configured yet, it will use the default logger
+ fire_event(MainKeyboardInterrupt())
  exit_code = ExitCodes.UnhandledError.value
 
  # This can be thrown by eg. argparse
  except SystemExit as e:
  exit_code = e.code
 
  except BaseException as e:
- logger.warning("Encountered an error:")
- logger.warning(str(e))
-
- if log_manager.initialized:
- logger.debug(traceback.format_exc())
- elif not isinstance(e, RuntimeException):
- # if it did not come from dbt proper and the logger is not
- # initialized (so there's no safe path to log to), log the
- # stack trace at error level.
- logger.error(traceback.format_exc())
+ fire_event(MainEncounteredError(e=e))
+ fire_event(MainStackTrace(stack_trace=traceback.format_exc()))
  exit_code = ExitCodes.UnhandledError.value
 
  sys.exit(exit_code)
@@ -208,7 +205,7 @@ def track_run(task):
  )
  except (NotImplementedException,
  FailedToConnectException) as e:
- logger.error('ERROR: {}'.format(e))
+ fire_event(MainEncounteredError(e=e))
  dbt.tracking.track_invocation_end(
  config=task.config, args=task.args, result_type="error"
  )
@@ -228,21 +225,20 @@ def run_from_args(parsed):
  # set log_format in the logger
  parsed.cls.pre_init_hook(parsed)
 
- logger.info("Running with dbt{}".format(dbt.version.installed))
+ fire_event(MainReportVersion(v=dbt.version.installed))
 
  # this will convert DbtConfigErrors into RuntimeExceptions
  # task could be any one of the task objects
  task = parsed.cls.from_args(args=parsed)
-
- logger.debug("running dbt with arguments {parsed}", parsed=str(parsed))
+ fire_event(MainReportArgs(args=parsed))
 
  log_path = None
  if task.config is not None:
  log_path = getattr(task.config, 'log_path', None)
  # we can finally set the file logger up
  log_manager.set_path(log_path)
  if dbt.tracking.active_user is not None: # mypy appeasement, always true
- logger.debug("Tracking: {}".format(dbt.tracking.active_user.state()))
+ fire_event(MainTrackingUserState(dbt.tracking.active_user.state()))
 
  results = None