def test_log_filtering_by_rule() -> None:
with temporary_dir() as tmpdir:
ob = create_options_bootstrapper([
f"--pants-workdir={tmpdir}",
'--log-levels-by-target={"debug_target": "debug"}'
])
# Do not set up a stdio destination, meaning that all messages will go to the log.
global_bootstrap_options = ob.bootstrap_options.for_global_scope()
with initialize_stdio(global_bootstrap_options):
native_engine.write_log(msg="log msg one",
level=LogLevel.INFO.level,
target="some.target")
native_engine.write_log(msg="log msg two",
level=LogLevel.DEBUG.level,
target="some.other.target")
native_engine.write_log(msg="log msg three",
level=LogLevel.DEBUG.level,
target="debug_target")
loglines = (Path(global_bootstrap_options.pants_workdir,
"pants.log").read_text().splitlines())
assert "[INFO] log msg one" in loglines[0]
assert "[DEBUG] log msg three" in loglines[1]
assert len(loglines) == 2
def mock_console(
options_bootstrapper: OptionsBootstrapper,
*,
stdin_content: bytes | str | None = None,
) -> Iterator[Tuple[Console, StdioReader]]:
global_bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope(
)
@contextmanager
def stdin_context():
if stdin_content is None:
yield open("/dev/null", "r")
else:
with temporary_file(binary_mode=isinstance(stdin_content,
bytes)) as stdin_file:
stdin_file.write(stdin_content)
stdin_file.close()
yield open(stdin_file.name, "r")
with initialize_stdio(global_bootstrap_options), stdin_context(
) as stdin, temporary_file(binary_mode=False) as stdout, temporary_file(
binary_mode=False) as stderr, stdio_destination(
stdin_fileno=stdin.fileno(),
stdout_fileno=stdout.fileno(),
stderr_fileno=stderr.fileno(),
):
# NB: We yield a Console without overriding the destination argument, because we have
# already done a sys.std* level replacement. The replacement is necessary in order for
# InteractiveProcess to have native file handles to interact with.
yield Console(use_colors=global_bootstrap_options.colors), StdioReader(
_stdout=Path(stdout.name), _stderr=Path(stderr.name))
def run_sync(self):
"""Synchronously run pantsd."""
os.environ.pop("PYTHONPATH")
global_bootstrap_options = self._bootstrap_options.for_global_scope()
# Set the process name in ps output to 'pantsd' vs './pants compile src/etc:: -ldebug'.
set_process_title(f"pantsd [{self._build_root}]")
# Switch log output to the daemon's log stream, and empty `env` and `argv` to encourage all
# further usage of those variables to happen via engine APIs and options.
self._close_stdio()
with initialize_stdio(global_bootstrap_options), argv_as(
tuple()), hermetic_environment_as():
# Install signal and panic handling.
ExceptionSink.install(
log_location=init_workdir(global_bootstrap_options),
pantsd_instance=True)
native_engine.maybe_set_panic_handler()
self._initialize_metadata()
# Check periodically whether the core is valid, and exit if it is not.
while self._core.is_valid():
time.sleep(self.JOIN_TIMEOUT_SECONDS)
# We're exiting: join the server to avoid interrupting ongoing runs.
self._logger.info(
"Waiting for ongoing runs to complete before exiting...")
native_engine.nailgun_server_await_shutdown(self._server)
self._logger.info("Exiting pantsd")
def run(self, start_time: float) -> ExitCode:
self.scrub_pythonpath()
options_bootstrapper = OptionsBootstrapper.create(env=self.env,
args=self.args,
allow_pantsrc=True)
with warnings.catch_warnings(record=True):
bootstrap_options = options_bootstrapper.bootstrap_options
global_bootstrap_options = bootstrap_options.for_global_scope()
# We enable logging here, and everything before it will be routed through regular
# Python logging.
stdin_fileno = sys.stdin.fileno()
stdout_fileno = sys.stdout.fileno()
stderr_fileno = sys.stderr.fileno()
with initialize_stdio(global_bootstrap_options), stdio_destination(
stdin_fileno=stdin_fileno,
stdout_fileno=stdout_fileno,
stderr_fileno=stderr_fileno,
):
# N.B. We inline imports to speed up the python thin client run, and avoids importing
# engine types until after the runner has had a chance to set PANTS_BIN_NAME.
if self._should_run_with_pantsd(global_bootstrap_options):
from pants.bin.remote_pants_runner import RemotePantsRunner
try:
remote_runner = RemotePantsRunner(self.args, self.env,
options_bootstrapper)
return remote_runner.run(start_time)
except RemotePantsRunner.Fallback as e:
logger.warning(
f"Client exception: {e!r}, falling back to non-daemon mode"
)
from pants.bin.local_pants_runner import LocalPantsRunner
# We only install signal handling via ExceptionSink if the run will execute in this process.
ExceptionSink.install(
log_location=init_workdir(global_bootstrap_options),
pantsd_instance=False)
runner = LocalPantsRunner.create(
env=CompleteEnvironment(self.env),
options_bootstrapper=options_bootstrapper)
return runner.run(start_time)
def mock_console(
options_bootstrapper: OptionsBootstrapper,
) -> Iterator[Tuple[Console, StdioReader]]:
global_bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope(
)
with initialize_stdio(global_bootstrap_options), open(
"/dev/null", "r") as stdin, temporary_file(
binary_mode=False) as stdout, temporary_file(
binary_mode=False) as stderr, stdio_destination(
stdin_fileno=stdin.fileno(),
stdout_fileno=stdout.fileno(),
stderr_fileno=stderr.fileno(),
):
# NB: We yield a Console without overriding the destination argument, because we have
# already done a sys.std* level replacement. The replacement is necessary in order for
# InteractiveProcess to have native file handles to interact with.
yield Console(use_colors=global_bootstrap_options.colors), StdioReader(
_stdout=Path(stdout.name), _stderr=Path(stderr.name))
def test_file_logging() -> None:
with temporary_dir() as tmpdir:
ob = create_options_bootstrapper([f"--pants-workdir={tmpdir}"])
# Do not set up a stdio destination, meaning that all messages will go to the log.
global_bootstrap_options = ob.bootstrap_options.for_global_scope()
with initialize_stdio(global_bootstrap_options):
logger = logging.getLogger(None)
cat = "🐈"
logger.warning("this is a warning")
logger.info("this is some info")
logger.debug("this is some debug info")
logger.info(f"unicode: {cat}")
loglines = (Path(global_bootstrap_options.pants_workdir,
"pants.log").read_text().splitlines())
print(loglines)
assert len(loglines) == 3
assert "[WARN] this is a warning" in loglines[0]
assert "[INFO] this is some info" in loglines[1]
assert f"[INFO] unicode: {cat}" in loglines[2]
def mock_console(
options_bootstrapper: OptionsBootstrapper,
*,
stdin_content: bytes | str | None = None,
) -> Iterator[tuple[Console, StdioReader]]:
global_bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope(
)
colors = (options_bootstrapper.full_options_for_scopes(
[GlobalOptions.get_scope_info()],
allow_unknown_options=True).for_global_scope().colors)
with initialize_stdio(global_bootstrap_options), stdin_context(
stdin_content) as stdin, temporary_file(
binary_mode=False) as stdout, temporary_file(
binary_mode=False) as stderr, stdio_destination(
stdin_fileno=stdin.fileno(),
stdout_fileno=stdout.fileno(),
stderr_fileno=stderr.fileno(),
):
# NB: We yield a Console without overriding the destination argument, because we have
# already done a sys.std* level replacement. The replacement is necessary in order for
# InteractiveProcess to have native file handles to interact with.
yield Console(use_colors=colors), StdioReader(
_stdout=Path(stdout.name), _stderr=Path(stderr.name))
