Jira (BOLT-901) Improve Plan Logging with apply

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer Summary: Print a summary metrics for each target of an aply at info level Improve Plan Logging with apply Add Comment

This message was sent by Atlassian JIRA (v7.7.1#77002-sha1:e75ca93)

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer

Problem I want useful human readable output showing the metrics from each targets apply during a plan. Solution When the format is human and plan_logging is active every run action should trigger the same output it would if the action was run on it's own from the CLI. * {{plan_logging}}: is only part of the human format and plan logging messages are printed on stdout not stderr * info level logging is primarily about logging full input/output of each action from a plan. * notice level logging is only used initially with the {{notice}} function from plans. * {{plan_logging}} messages should be indented to make it easier to scan * Individual node results should be output as part of plan logging when there are fewer than {{n}} targets for an action. Questions: * How can we show human readable verbose apply output( ie event logs from an apply report )? * Do we need to expose access to print human readable messages to stdout as a plan function ? Is or is {{ notice }} enough? (defer and build if needed) * Do we need to show progress of actions when the format is json? (not initially defer and build later if needed) * Do we need an option for the bolt user (rather then the author) to suppress individual node results from the human format?(defer and build later if needed) * How will this work with BoltSpec? (defer and build later if needed. pass a noop outputter to executor for now)

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer

Problem I want useful human readable output showing the metrics events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan.

Solution When the format is human and plan_logging is active every run action should trigger the same output it would if the action was run on it's own from the CLI. * {{plan_logging}}: is only part of the human format and plan logging messages are printed on stdout not stderr * info level logging is primarily about logging full input/output of each action from a plan. * notice level logging is only used initially with the {{notice}} function from plans. * {{plan_logging}} messages should be indented to make it easier to scan * Individual node results should be output as part of plan logging when there are fewer than {{n}} targets for an action. Questions:

* How can we show human readable verbose apply output(ie event logs from an apply report)? * Do we need to expose access to print human readable messages to stdout as a plan function or is {{notice}} enough? (defer and build if needed)

* Do we need to show progress of actions when the format is json? (not initially defer and build later if needed) * Do we need an option for the bolt user (rather then the author) to suppress individual node results from the human format?(defer and build later if needed) * How will this work with BoltSpec? (defer and build later if needed. pass a noop outputter to executor for now)

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan.

Solution When the format is human and plan_logging is active every run action should trigger the same output it would if the action was run on it's own from the CLI. * {{plan_logging}}: is only part of the human format and plan logging messages are printed on stdout not stderr * info level logging is primarily about logging full input/output of each action from a plan. * notice level logging is only used initially with the {{notice}} function from plans. * {{plan_logging}} messages should be indented to make it easier to scan * Individual node results should be output as part of plan logging when there are fewer than {{n}} targets for an action. Questions: * How can we show human readable verbose apply output(ie event logs from an apply report)? * Do we need to expose access to print human readable messages to stdout as a plan function or is {{notice}} enough? (defer and build if needed) * Do we need to show progress of actions when the format is json? (not initially defer and build later if needed) * Do we need an option for the bolt user (rather then the author) to suppress individual node results from the human format?(defer and build later if needed) * How will this work with BoltSpec? (defer and build later if needed. pass a noop outputter to executor for now)

Possible short term fix: * add new formatter "verbose-human". verbose human output should print full results from actions during a plan run.

Add Comment

[Reid Vandewiele (JIRA)]

Reid Vandewiele commented on BOLT-901

Re: Improve Plan Logging with apply Ended up throwing this function together for now. function pe_xl::print_apply_result(ApplyResult $apply) { $apply.report['logs'].each |$log| { # TODO: include file and line number, if present notice("${log['time']} ${log['level'].upcase} ${log['source']} ${log['message']}") }   $status = $apply.report['status'] $message = $apply.message $target = $apply.target.name notice("\"${status}\" on ${target}: ${message}") } Looks something like this when running. plan pe_xl::test( TargetSpec $nodes, ) {   apply($nodes) { notify { 'foobar': } }.each |$result| { pe_xl::print_apply_result($result) }   } [reidmv@halcyon:~/src/reidmv-pe_xl/] % bolt --modulepath ~/modules plan run pe_xl::test -n localhost Starting: plan pe_xl::test Starting: apply catalog on localhost Finished: apply catalog with 0 failures in 9.04 sec 2019-01-24T10:02:59.684536000-08:00 NOTICE Puppet foobar 2019-01-24T10:02:59.686271000-08:00 NOTICE /Stage[main]/Main/Notify[foobar]/message defined 'message' as 'foobar' 2019-01-24T10:02:59.692682000-08:00 NOTICE Puppet Applied catalog in 0.01 seconds changed: 1, failed: 0, unchanged: 0 skipped: 0, noop: 0 on localhost Finished: plan pe_xl::test in 9.11 sec Plan completed successfully with no result

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901

Improve Plan Logging with apply

Change By: Alex Dreyer Sprint: Bolt Ready for Grooming

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Solution When the format is human and plan_logging is active every run action should trigger the same output it would if the action was run on it's own from the CLI. * {{plan_logging}}: is only part of the human format and plan logging messages are printed on stdout not stderr * info level logging is primarily about logging full input/output of each action from a plan. * notice level logging is only used initially with the {{notice}} function from plans. * {{plan_logging}} messages should be indented to make it easier to scan * Individual node results should be output as part of plan logging when there are fewer than {{n}} targets for an action. Questions: * How can we show human readable verbose apply output(ie event logs from an apply report)? * Do we need to expose access to print human readable messages to stdout as a plan function or is {{notice}} enough? (defer and build if needed) * Do we need to show progress of actions when the format is json? (not initially defer and build later if needed) * Do we need an option for the bolt user (rather then the author) to suppress individual node results from the human format?(defer and build later if needed) * How will this work with BoltSpec? (defer and build later if needed. pass a noop outputter to executor for now)

Possible short term fix fixes :

* add new formatter "verbose-human". verbose human output should print full results from actions during a plan run.

* clean up output from {{apply_prep}} and {{apply}} so they only logs a single result for each target.

Add Comment

[David Kramer (JIRA)]

David Kramer assigned an issue to Nick Lewis

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: David Kramer Assignee: Nick Lewis

Add Comment

[David Kramer (JIRA)]

David Kramer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: David Kramer Sprint: Bolt Ready for Grooming Kanban

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Alex Dreyer

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan.

Solution Refactor logging and outputting

When the format is human

* All actions and plan_logging is active every run action should trigger the same plan output it would if function(notice/warm/etc) are handed to the action was run on it's own from the CLI outputter . * {{ plan_logging --verbose }} : is only part of becomes an option for the human format and plan logging messages are printed on stdout outputter not stderr the logger. * info level logging is primarily about logging full input/output of each action from a By default "single actions" {{bolt command run}} {{bolt task run}} as opposed to {{bolt plan . * notice level logging is only used initially run}} are run with the {{ notice --verbose }} function from plans. * {{ plan_logging --no-verbose }} messages should be indented becomes and option to make it easier to scan override this behavior. * Individual node results should be output as part of " plan logging when there are fewer than " becomes and outputter concept used by the json outputter initially Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{ n --verbose }} targets for an action. Questions: * How can we show With apply human readable outputter only prints summary of entire run without verbose * With {{--verbose}} apply output(ie event human outputter prints logs from an apply the report )? showing at least changes. JSON outputter: * Do we need When in non-plan mode behaves are it does currently. * When in plan mode logs only the plan result to expose access to print human readable messages to stdout as a plan function or is {{notice}} enough? (defer and build if needed) . * Do we need When in plan mode and verbose mode sends intermediate results to show progress of actions when the format is json? stderr. ( not initially defer and build later if needed perhaps through logger.notice? ) Puppet log functions: * Do we need an option for Eventually these should be handled by the bolt user ( outputter rather then the author) logger directly but this is left to suppress individual node results from the human format?(defer and build a later if needed) * How will this work with BoltSpec? (defer and build later if needed ticket . pass a noop outputter to executor for now) Possible short term fixes Questions : * add new formatter "verbose-human". verbose human output How should print full results from actions during a plan run. * clean up output from {{ the steps of apply_prep }} and {{ be logged? Ideally each apply }} so they only logs prep would be a single action with a single result for each target at {{--verbose}} .

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan.

Refactor logging and outputting * All actions and plan output function(notice/warm/etc) are handed to the outputter. * {{--verbose}} becomes an option for the outputter not the logger. * By default "single actions" {{bolt command run}} {{bolt task run}} as opposed to {{bolt plan run}} are run with {{--verbose}} {{--no-verbose}} becomes and option to override this behavior. * "plan logging" becomes and outputter concept used by the json outputter initially * {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events.

Human outputter * Human outputter without verbose prints starting action and summary for action messages.

* Human outputter prints full node-level result with {{--verbose}} * With apply human outputter only prints summary of entire run without verbose * With {{--verbose}} apply human outputter prints logs from the report showing at least changes. JSON outputter: * When in non-plan mode behaves are it does currently. * When in plan mode logs only the plan result to stdout. * When in plan mode and verbose mode sends intermediate results to stderr.(perhaps through logger.notice?) Puppet log functions: * Eventually these should be handled by the outputter rather then the logger directly but this is left to a later ticket. Questions: * How should the steps of apply_prep be logged? Ideally each apply prep would be a single action with a single result for each target at {{--verbose}}.

Add Comment

[Alex Dreyer (JIRA)]

Questions Apply_prep : * How should the steps this needs to have better log events. that is out of apply_prep be logged? Ideally each apply prep would be a single action with a single result scope for each target at this ticket. For now just rely on {{ --verbose without_default_logging }} .

Add Comment

[Alex Dreyer (JIRA)]

Apply_prep apply_prep/get_resources : * this needs these probably need to have better log specific events the outputter can handle . that That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Alex Dreyer

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting * All actions and plan output function(notice/warm/etc) are handed to the outputter. * {{--verbose}} becomes an option for the outputter not the logger. * By default "single actions" {{bolt command run}} {{bolt task run}} as opposed to {{bolt plan run}} are run with {{--verbose}} {{--no-verbose}} becomes and option to override this behavior. * "plan logging" becomes and outputter concept used by the json outputter initially * {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events. Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{--verbose}} * With apply human outputter only prints summary of entire run without verbose * With {{--verbose}} apply human outputter prints logs from the report showing at least changes. JSON outputter: * When in non-plan mode behaves are it does currently. * When in plan mode logs only the plan result to stdout. * When in plan mode and verbose mode sends intermediate results to stderr.(perhaps through logger.notice?)

* logs entire jsonformat of apply result on stderr for each node at {{--verbose}}

Puppet log functions: * Eventually these should be handled by the outputter rather then the logger directly but this is left to a later ticket.

apply_prep/get_resources: * these probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Nick Lewis

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting * All actions and plan output function(notice/warm/etc) are handed to the outputter. * {{--verbose}} becomes an option for the outputter not the logger.

* By default "single actions" {{bolt command run}} ( {{bolt task run}} as opposed to {{bolt plan run}} ) are run with verbosely. {{-- verbose}} {{-- no-verbose}} becomes and is an option to override this behavior.

* "plan logging" becomes and outputter concept used by the json outputter initially * {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events. Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{--verbose}} * With apply human outputter only prints summary of entire run without verbose * With {{--verbose}} apply human outputter prints logs from the report showing at least changes. JSON outputter: * When in non-plan mode behaves are it does currently. * When in plan mode logs only the plan result to stdout. * When in plan mode and verbose mode sends intermediate results to stderr.(perhaps through logger.notice?) * logs entire jsonformat of apply result on stderr for each node at {{--verbose}} Puppet log functions: * Eventually these should be handled by the outputter rather then the logger directly but this is left to a later ticket. apply_prep/get_resources: * these probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Nick Lewis

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting

* All actions and plan output function ( notice plan start / warm finish, step start / etc finish, node start/result ) are handed to the outputter as an event stream .

* {{--verbose}} becomes an option for the outputter not the logger.

* By default " single actions verbose " {{bolt command run}} ({{bolt task run}} as opposed is now defined to {{bolt plan run}}) mean node-level results are run verbosely included in the output when using the human format . "verbose" has no meaning for the JSON format. * Plans default to _non_-verbose, everything else defaults to verbose. {{--no-verbose}} is accepted as an option addition to override this behavior. {{--verbose}} * "plan logging" becomes and an outputter concept , rather than an executor concept, used by the json outputter initially

* {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events. Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{--verbose}}

* With For {{bolt apply }} _without_ verbose, human outputter only prints a summary of entire the run without verbose * With For {{ --verbose bolt apply }} apply _with_ verbose, human outputter prints logs from the each report showing at least changes. This is probably notice level messages and above, maybe excluding messages where the source is "Puppet". * All output from this outputter can go to stdout (currently messages go to stderr for plans) JSON outputter: * When in non-plan mode behaves are as it does currently. * When in plan mode logs only the plan Logs entire JSON format of {{apply}} result to stdout. on stderr for each node at {{--verbose}} * When in plan mode and verbose mode sends This outputter can show intermediate results to on stderr in human format, but doesn't have to for this ticket Log output: * The default console log level is now "warn" . (perhaps through No "human-oriented" output should come from the logger except for warnings and errors . notice?) * logs entire jsonformat of apply result on stderr Log files still default to "info". * {{--debug}} still sets debug level for each node at console logger, {{--verbose}} does not affect the logger at all * A "logger outputter" should consume the event stream and translate each event to appropriate log messages that are passed to the logger Puppet log functions: * Eventually these should be handled by the outputter rather then than the logger directly , but this is left to a later ticket. apply_prep/get_resources: * these These probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Alex Dreyer (JIRA)]

Alex Dreyer updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Alex Dreyer

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting

* All actions (plan start/finish, step start/finish, node start/result) are handed to the outputter as an event stream.

* {{--verbose}} becomes an option for the outputter not the logger.

* "verbose" is now defined to mean node-level results are included in the output when using the human format. "verbose" has no meaning for the JSON format. * Plans default to _non_ non -verbose, everything else defaults to verbose. {{--no-verbose}} is accepted as an addition to {{--verbose}} * "plan logging" becomes an outputter concept, rather than an executor concept, used by the json outputter initially

* {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events. Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{--verbose}}

* For {{bolt apply}} _without_ verbose, human outputter only prints a summary of the run * For {{bolt apply}} _with_ verbose, human outputter prints logs from each report showing at least changes. This is probably notice level messages and above, maybe excluding messages where the source is "Puppet".

* All output from this outputter can go to stdout (currently messages go to stderr for plans) JSON outputter:

* When in non-plan mode behaves as it does currently. * Logs entire JSON format of {{apply}} result on stderr for each node at {{--verbose}} * This outputter can show intermediate results on stderr in human format, but doesn't have to for this ticket Log output: * The default console log level is now "warn". No "human-oriented" output should come from the logger except for warnings and errors. * Log files still default to "info". * {{--debug}} still sets debug level for console logger, {{--verbose}} does not affect the logger at all

* A "logger outputter" should consume the event stream and translate each event to appropriate log messages that are passed to the logger Puppet log functions:

* Eventually these should be handled by the outputter rather than the logger directly, but this is left to a later ticket. apply_prep/get_resources: * These probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Nick Lewis

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting * All actions (plan start/finish, step start/finish, node start/result) are handed to the outputter as an event stream. * {{--verbose}} becomes an option for the outputter not the logger. * "verbose" is now defined to mean node-level results are included in the output when using the human format. "verbose" has no meaning for the JSON format.

* Plans default to non-verbose, everything else defaults to verbose. {{ \ - \ -no \ -verbose}} is accepted as an addition to {{--verbose}}

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Nick Lewis

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting * All actions (plan start/finish, step start/finish, node start/result) are handed to the outputter as an event stream. * {{--verbose}} becomes an option for the outputter not the logger. * "verbose" is now defined to mean node-level results are included in the output when using the human format. "verbose" has no meaning for the JSON format. * Plans default to non-verbose, everything else defaults to verbose. {{ \ - \ -no \

-verbose}} is accepted as an addition to {{--verbose}} * "plan logging" becomes an outputter concept, rather than an executor concept , used by the json outputter initially

* {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events. Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{--verbose}} * For {{bolt apply}} _without_ verbose, human outputter only prints a summary of the run * For {{bolt apply}} _with_ verbose, human outputter prints logs from each report showing at least changes. This is probably notice level messages and above, maybe excluding messages where the source is "Puppet". * All output from this outputter can go to stdout (currently messages go to stderr for plans) JSON outputter: * When in non-plan mode behaves as it does currently. * Logs entire JSON format of {{apply}} result on stderr for each node at {{--verbose}} * This outputter can show intermediate results on stderr in human format, but doesn't have to for this ticket Log output: * The default console log level is now "warn". No "human-oriented" output should come from the logger except for warnings and errors. * Log files still default to "info".

* {{--debug - }} still sets debug level for console logger, {{- - verbose}} does not affect the logger at all

* A "logger outputter" should consume the event stream and translate each event to appropriate log messages that are passed to the logger Puppet log functions: * Eventually these should be handled by the outputter rather than the logger directly, but this is left to a later ticket. apply_prep/get_resources: * These probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply Change By: Nick Lewis

Problem I want useful human readable output showing the events from each targets apply during a plan. This is especially useful when debugging an apply statement in a plan. Refactor logging and outputting * All actions (plan start/finish, step start/finish, node start/result) are handed to the outputter as an event stream. * {{--verbose}} becomes an option for the outputter not the logger. * "verbose" is now defined to mean node-level results are included in the output when using the human format. "verbose" has no meaning for the JSON format.

* Plans default to non-verbose, everything else defaults to verbose. {{--no-verbose}} is accepted as an addition to {{--verbose}}

* "plan logging" becomes an outputter concept, rather than an executor concept

* {{without_default_logging}} becomes state tracked on the outputter that causes it to simply ignore action events. Human outputter * Human outputter without verbose prints starting action and summary for action messages. * Human outputter prints full node-level result with {{--verbose}} * For {{bolt apply}} _without_ verbose, human outputter only prints a summary of the run * For {{bolt apply}} _with_ verbose, human outputter prints logs from each report showing at least changes. This is probably notice level messages and above, maybe excluding messages where the source is "Puppet". * All output from this outputter can go to stdout (currently messages go to stderr for plans) JSON outputter: * When in non-plan mode behaves as it does currently. * Logs entire JSON format of {{apply}} result on stderr for each node at {{--verbose}} * This outputter can show intermediate results on stderr in human format, but doesn't have to for this ticket Log output: * The default console log level is now "warn". No "human-oriented" output should come from the logger except for warnings and errors. * Log files still default to "info".

* {{\-\-debug}} still sets debug level for console logger, {{ \ - \- verbose}} does not affect the logger at all

* A "logger outputter" should consume the event stream and translate each event to appropriate log messages that are passed to the logger Puppet log functions: * Eventually these should be handled by the outputter rather than the logger directly, but this is left to a later ticket. apply_prep/get_resources: * These probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

* {{ \ - \ -debug - }} still sets debug level for console logger, {{-verbose}} does not affect the logger at all

* A "logger outputter" should consume the event stream and translate each event to appropriate log messages that are passed to the logger Puppet log functions: * Eventually these should be handled by the outputter rather than the logger directly, but this is left to a later ticket. apply_prep/get_resources: * These probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

--no-verbose}} is accepted as an addition to {{--verbose}}

* {{\-\-debug}} still sets debug level for console logger, {{\-\-verbose}} does not affect the logger at all

* A "logger outputter" should consume the event stream and translate each event to appropriate log messages that are passed to the logger Puppet log functions: * Eventually these should be handled by the outputter rather than the logger directly, but this is left to a later ticket. apply_prep/get_resources: * These probably need to have specific events the outputter can handle. That is out of scope for this ticket. For now just rely on {{without_default_logging}}

Add Comment

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Nick Lewis Release Notes: Enhancement

Add Comment

[Nick Lewis (JIRA)]

Nick Lewis updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Nick Lewis Release Notes Summary: `bolt apply` and the `apply` function from plans will now show log messages for changes and failures that happened while applying the Puppet code.

Add Comment

[David Kramer (JIRA)]

David Kramer assigned an issue to Cas Donoghue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: David Kramer Assignee: Nick Lewis Cas Donoghue

Add Comment

[Cas Donoghue (JIRA)]

Cas Donoghue updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Cas Donoghue Fix Version/s: BOLT Next

Add Comment

[Melissa Amos (JIRA)]

Melissa Amos updated an issue

Puppet Task Runner / BOLT-901 Improve Plan Logging with apply

Change By: Melissa Amos Labels: docs_reviewed

Add Comment