logging in a cmd2 application

[rADikal8e7]

Is there a way to log everything done on a cmd2 application by also redirecting the self.poutput to a log file.

I am using transcripts feature and that requires the use of self.poutput to validate tests.

Basically i am looking to see if cmd2 is capable of handling the following flow.

• Log everything from a cmd2 application (cmd used at the cmd prompt and the output)
• use the log and make changes to the output(use regex) and use the --test functionality to run the log file as a transcript.

[kmvanbrunt]

You can use cmd2 to create transcripts in 2 ways.

The first is with the history command using its --transcript option. It runs specified commands from your history and writes a transcript file with prompt and output. Here are the basic steps.

Run commands to put them in your history

alias create hp help
alias list hp
alias delete hp

Run history to identify the command numbers you want included in the transcript.

(Cmd) history
    1  alias create hp help
    2  alias list hp
    3  alias delete hp

Create the transcript file

history 1:3 --transcript transcript.txt

The second way to do this is with the run_script command.

1. Create a script file with all the commands you want to run.
2. In your CLI, run set echo true. echo is a cmd2 environment variable which tells scripts to output the prompt/command line for each command it runs. You can even put this as the first line of your script. In this case, the output for set will end up in the transcript, but you can easily remove it when you edit the transcript file.
3. Run run_script myscript.txt > transcript.txt

Let me know if you have any more questions.

[rADikal8e7]

i get the part about the transcript generation(its well documented btw).

My query is more about logging the cmd2 application(something like a traditional logger module which would generate a logfile). If i import logger and use log.outpu("some message") i can no longer use the transcript --test or the run_script functionality since it relies on self.poutput

[kmvanbrunt]

I don't have an easy answer to that. The first thing that comes to mind is using tee.
python cmd2.py | tee log.txt.

The issue with that approach is you won't have any of the nice readline features like tab completion, up arrow history, etc.

[kmvanbrunt]

Nevermind about using tee. That won't capture the typed command.

[rADikal8e7]

Now that i think about it.Even with a logger i can only log the output using something like log.info(some message). i can't get a log of the prompt and commands passed to it.

i think logfile should be an argument while initializing the cmd2.Cmd app. Like how the persistent history file is passed to the init.

    def __init__(self, hist_file):
        super().__init__(multiline_commands=['config', 'verify'], persistent_history_file=hist_file,
                         persistent_history_length=500)

[rADikal8e7]

any workaround on the logger functionality of a cmd2 application? would the transcript feature break if i use logger.info(message) instead of poutput(message) to display?

[kmvanbrunt]

Here is a possible solution. It uses a cmd2 postparsing hook to log each command line. And then it overrides self.poutput() to write all output to your log file before its printed.

import logging
from typing import (
    Any,
)

from cmd2 import (
    cmd2,
)


class MyApp(cmd2.Cmd):

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.register_postparsing_hook(self._postparsing_hook)

        # Write logs to a file and don't include the log tags.
        logging.basicConfig(filename='log.txt', format='%(message)s', encoding='utf-8', level=logging.INFO)

    def _postparsing_hook(self, data: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:
        """Log the prompt and typed command. This runs right after the command line is parsed."""

        # Handle multiline commands by restoring continuation_prompts
        command_line = data.statement.raw.replace("\n", f"\n{self.continuation_prompt}")
        logging.info(f"{self.prompt}{command_line}")
        return data

    def poutput(self, msg: Any = '', *, end: str = '\n') -> None:
        """Override poutput() to log all data before calling the parent"""

        # Remove ansi style characters (e.g. color) which we don't want in the log file
        # This originally was "{msg}{end}", but that printed too many newlines in the log file.
        # So you might want to mess with the formatting to fit your preference.
        to_log = cmd2.ansi.strip_style(f"{msg}")
        logging.info(to_log)
        super().poutput(msg, end=end)

[kmvanbrunt]

I updated the above example code to restore continuation prompts in multiline commands when logging.

[rADikal8e7]

Forgot to update. This method works. Thanks @kmvanbrunt