cloudos_cli.logging.logger

Functions

mask_secret_values(text, secrets)	Replace each raw secret value found in text.
redact_argv(argv[, secrets])	Return a copy of argv with the values of secret options masked.
redact_params(params)	Return a copy of params with secret-bearing values masked.
secret_param_values(params)	Return the raw values of the secret params, to mask wherever they appear.
secure_log_dir()	Create ~/.cloudos/logs if needed and restrict it, and existing log files, to the owner.
setup_logging(debug)
update_command_context_from_click(ctx)	Call this AFTER Click parsed args.

Classes

CommandContextFilter([command, params])	Injects record.command and record.params (with secrets redacted) everywhere.
LogFormatter(*[, fmt_keys])
PrivateFileHandler(filename[, mode, ...])	FileHandler whose log file is only readable by its owner (0600).

class cloudos_cli.logging.logger.CommandContextFilter(command=None, params=None)

Bases: Filter

Injects record.command and record.params (with secrets redacted) everywhere.

filter(record)

Determine if the specified record is to be logged.

Returns True if the record should be logged, or False otherwise. If deemed appropriate, the record may be modified in-place.

set_from_click_ctx(ctx)

set_seed_from_argv()

class cloudos_cli.logging.logger.LogFormatter(*, fmt_keys=None)

Bases: Formatter

converter()

localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,

tm_sec,tm_wday,tm_yday,tm_isdst)

Convert seconds since the Epoch to a time tuple expressing local time. When ‘seconds’ is not passed in, convert the current time instead.

default_msec_format = '%s,%03d'

default_time_format = '%Y-%m-%d %H:%M:%S'

format(record)

Format the specified record as text.

The record’s attribute dictionary is used as the operand to a string formatting operation which yields the returned string. Before formatting the dictionary, a couple of preparatory steps are carried out. The message attribute of the record is computed using LogRecord.getMessage(). If the formatting string uses the time (as determined by a call to usesTime(), formatTime() is called to format the event time. If there is exception information, it is formatted using formatException() and appended to the message.

Parameters:

record (LogRecord)

Return type:

str

formatException(ei)

Format and return the specified exception information as a string.

This default implementation just uses traceback.print_exception()

formatMessage(record)

formatStack(stack_info)

This method is provided as an extension point for specialized formatting of stack information.

The input data is a string as returned from a call to traceback.print_stack(), but with the last trailing newline removed.

The base implementation just returns the value passed in.

formatTime(record, datefmt=None)

Return the creation time of the specified LogRecord as formatted text.

This method should be called from format() by a formatter which wants to make use of a formatted time. This method can be overridden in formatters to provide for any specific requirement, but the basic behaviour is as follows: if datefmt (a string) is specified, it is used with time.strftime() to format the creation time of the record. Otherwise, an ISO8601-like (or RFC 3339-like) format is used. The resulting string is returned. This function uses a user-configurable function to convert the creation time to a tuple. By default, time.localtime() is used; to change this for a particular formatter instance, set the ‘converter’ attribute to a function with the same signature as time.localtime() or time.gmtime(). To change it for all formatters, for example if you want all logging times to be shown in GMT, set the ‘converter’ attribute in the Formatter class.

usesTime()

Check if the format uses the creation time of the record.

class cloudos_cli.logging.logger.PrivateFileHandler(filename, mode='a', encoding=None, delay=False, errors=None)

Bases: FileHandler

FileHandler whose log file is only readable by its owner (0600).

On Windows, chmod only toggles the read-only flag, so access there is governed by the ACL inherited from the user’s profile directory.

acquire()

Acquire the I/O thread lock.

addFilter(filter)

Add the specified filter to this handler.

close()

Closes the stream.

createLock()

Acquire a thread lock for serializing access to the underlying I/O.

emit(record)

Emit a record.

If the stream was not opened because ‘delay’ was specified in the constructor, open it before calling the superclass’s emit.

If stream is not open, current mode is ‘w’ and _closed=True, record will not be emitted (see Issue #42378).

filter(record)

Determine if a record is loggable by consulting all the filters.

The default is to allow the record to be logged; any filter can veto this by returning a false value. If a filter attached to a handler returns a log record instance, then that instance is used in place of the original log record in any further processing of the event by that handler. If a filter returns any other true value, the original log record is used in any further processing of the event by that handler.

If none of the filters return false values, this method returns a log record. If any of the filters return a false value, this method returns a false value.

Changed in version 3.2: Allow filters to be just callables.

Changed in version 3.12: Allow filters to return a LogRecord instead of modifying it in place.

flush()

Flushes the stream.

format(record)

Format the specified record.

If a formatter is set, use it. Otherwise, use the default formatter for the module.

get_name()

handle(record)

Conditionally emit the specified logging record.

Emission depends on filters which may have been added to the handler. Wrap the actual emission of the record with acquisition/release of the I/O thread lock.

Returns an instance of the log record that was emitted if it passed all filters, otherwise a false value is returned.

handleError(record)

Handle errors which occur during an emit() call.

This method should be called from handlers when an exception is encountered during an emit() call. If raiseExceptions is false, exceptions get silently ignored. This is what is mostly wanted for a logging system - most users will not care about errors in the logging system, they are more interested in application errors. You could, however, replace this with a custom handler if you wish. The record which was being processed is passed in to this method.

property name

release()

Release the I/O thread lock.

removeFilter(filter)

Remove the specified filter from this handler.

setFormatter(fmt)

Set the formatter for this handler.

setLevel(level)

Set the logging level of this handler. level must be an int or a str.

setStream(stream)

Sets the StreamHandler’s stream to the specified value, if it is different.

Returns the old stream, if the stream was changed, or None if it wasn’t.

set_name(name)

terminator = '\n'

cloudos_cli.logging.logger.mask_secret_values(text, secrets)

Replace each raw secret value found in text.

The stripped value is what’s searched for, so “ KEY” is masked as “ *” and “KEY” as “*”.

cloudos_cli.logging.logger.redact_argv(argv, secrets=None)

Return a copy of argv with the values of secret options masked.

If secrets is a set, the raw values that were masked are added to it.

cloudos_cli.logging.logger.redact_params(params)

Return a copy of params with secret-bearing values masked.

cloudos_cli.logging.logger.secret_param_values(params)

Return the raw values of the secret params, to mask wherever they appear.

cloudos_cli.logging.logger.secure_log_dir()

Create ~/.cloudos/logs if needed and restrict it, and existing log files, to the owner.

Never raises, so a directory we can’t change does not break the CLI.

cloudos_cli.logging.logger.setup_logging(debug)

cloudos_cli.logging.logger.update_command_context_from_click(ctx)

Call this AFTER Click parsed args.