close

keyboard_arrow_left

Table of Contents Expand all

play_arrow Overview
- play_arrow Junos Automation Scripts Overview
- play_arrow Junos XML Management Protocol and Junos XML API Overview
play_arrow Automation Scripting Using XSLT
- play_arrow XSLT Overview
- play_arrow Standard XPath and XSLT Functions Used in Automation Scripts
- play_arrow Standard XSLT Elements and Attributes Used in Automation Scripts
play_arrow Automation Scripting Using SLAX
- play_arrow SLAX Overview
- play_arrow SLAX Statements
- play_arrow The libslax Distribution for Automation Scripting
play_arrow Automation Scripting Using Python
- play_arrow Python Overview
play_arrow Automation Script Input
- play_arrow Global Parameters in Automation Scripts
  - Global Parameters and Variables in Junos OS Automation Scripts
play_arrow Extension Functions and Named Templates for Automation Scripts
play_arrow Manage Automation Scripts
- play_arrow Store and Enable Scripts
- play_arrow Configure a Remote Source for Scripts
- play_arrow Configure the Session Protocol for Scripts
  - Understanding the Session Protocol in Automation Scripts
  - Example: Specify the Session Protocol for a Connection within Scripts
- play_arrow Control Execution of Scripts
- play_arrow Synchronize Scripts Between Routing Engines
- play_arrow Convert Scripts Between SLAX and XSLT
  - Convert Scripts Between SLAX and XSLT
play_arrow Commit Scripts
- play_arrow Commit Scripts Overview
  - Commit Script Overview
  - How Commit Scripts Work
- play_arrow Create and Execute Commit Scripts
- play_arrow Generate a Custom Warning, Error, or System Log Message Using Commit Scripts
- play_arrow Generate Persistent or Transient Configuration Changes Using Commit Scripts
- play_arrow Create Custom Configuration Syntax with Commit Script Macros
- play_arrow Commit Script Examples
- play_arrow Junos XML and XSLT Tag Elements Used in Commit Scripts
- play_arrow Troubleshoot Commit Scripts
play_arrow Op Scripts
- play_arrow Op Scripts Overview
  - Op Script Overview
  - How Op Scripts Work
- play_arrow Create and Execute Op Scripts
- play_arrow Op Script Examples
- play_arrow Provision Services Using Service Template Automation
  - Service Template Automation Overview
  - Example: Configure Service Template Automation
- play_arrow Troubleshoot Op Scripts
  - Trace Op Script Processing on Devices Running Junos OS
  - Trace Script Processing on Devices Running Junos OS Evolved
play_arrow Event Policies and Event Scripts
play_arrow SNMP Scripts
- play_arrow SNMP Scripts Overview
  - SNMP Scripts Overview
- play_arrow Create and Execute SNMP Scripts
- play_arrow SNMP Script Example
  - Example: Process Unsupported OIDs with an SNMP Script
- play_arrow Troubleshoot SNMP Scripts
  - Trace SNMP Script Processing on Devices Running Junos OS
  - Trace Script Processing on Devices Running Junos OS Evolved
play_arrow Configuration Statements and Operational Commands
- Junos CLI Reference Overview

list Table of Contents

English

Trace Commit Script Processing on Devices Running Junos OS

date_range 08-Apr-25

arrow_backward

arrow_forward

Commit script tracing operations track commit script operations and record them in a log file. The logged error descriptions provide detailed information to help you solve problems faster.

On Junos OS, the default operation of commit script tracing is to log important events, which include errors, warnings, progress messages, and script processing events, in the /var/log/cscript.log file on the device. When the file cscript.log reaches 128 kilobytes (KB), it is renamed with a number 0 through 9 (in ascending order) appended to the end of the file and then compressed. For example, the log file is saved as cscript.log.0.gz, then cscript.log.1.gz until there are 10 trace files. Then the oldest trace file (cscript.log.9.gz) is overwritten.

Junos OS Evolved captures trace data for all applications by default and collects the data for all script types in trace files that correspond to the cscript application. To view the trace data, issue the show trace application cscript command. For more information, see Trace Script Processing on Devices Running Junos OS Evolved.

Minimum Configuration for Tracing for Commit Script Operations

If no commit script trace options are configured, the simplest way to view the trace output of a commit script is to configure the output trace flag and issue the show log cscript.log | last command. To do this, perform the following steps:

If you have not done so already, enable a commit script by including the file statement at the [edit system scripts commit] hierarchy level:
```
[edit system scripts commit]
user@host# set file filename 
```
Enable trace options by including the traceoptions flag output statement at the [edit system scripts commit] hierarchy level:
```
[edit system scripts commit]
user@host# set traceoptions flag output
```
Commit the configuration.
```
[edit]
user@host# commit
```
Display the resulting trace messages recorded in the file /var/log/cscript.log. At the end of the log is the output generated by the commit script you enabled in Step 1. To display the end of the log, issue the show log cscript.log | lastoperational mode command:
```
[edit]
user@host# run show log cscript.log | last
```

Table 1 summarizes useful filtering commands that display selected portions of the cscript.log file.

Table 1: Commit Script Tracing Operational Mode Commands
Task	Command
Display logging data associated with all commit script processing.	`show log cscript.log`
Display script processing for only the most recent commit operation.	`show log cscript.log \| last`
Display processing for script errors.	`show log cscript.log \| match error`
Display script processing for a particular script.	`show log cscript.log \| match filename`

Example: Minimum Configuration for Enabling Traceoptions for Commit Scripts

Display the trace output for the commit script file source-route.xsl:

content_copy zoom_out_map
[edit]
system {
    scripts {
        commit {
            file source-route.xsl;
            traceoptions {
                flag output;
            }
        }
    }
}

content_copy zoom_out_map
[edit]
user@host# commit and-quit

user@host> show log cscript.log | last
Jun 20 10:21:24 summary: changes 0, transients 0 (allowed), syslog 0
Jun 20 10:24:15 commit script processing begins
Jun 20 10:24:15 reading commit script configuration
Jun 20 10:24:15 testing commit script configuration
Jun 20 10:24:15 opening commit script '/var/db/scripts/commit/source-route.xsl'
Jun 20 10:24:15 script file '/var/db/scripts/commit/source-route.xsl': size=699; md5 = d947972b429d17ce97fe987d94add6fd
Jun 20 10:24:15 reading commit script 'source-route.xsl'
Jun 20 10:24:15 running commit script 'source-route.xsl'
Jun 20 10:24:15 processing commit script 'source-route.xsl'
Jun 20 10:24:15 results of 'source-route.xsl'
Jun 20 10:24:15 begin dump
<commit-script-output xmlns:junos="http://xml.juniper.net/junos/*/junos" xmlns:xnm="http://xml.juniper.net/xnm/1.1/xnm" xmlns:jcs="http://xml.juniper.net/junos/commit-scripts/1.0">
    <xnm:warning>
        <edit-path>[edit chassis]</edit-path>
        <message>IP source-route processing is not enabled.</message>
    </xnm:warning>
</commit-script-output>Jun 20 10:24:15 end dump
Jun 20 10:24:15 no errors from source-route.xsl
Jun 20 10:24:15 saving commit script changes
Jun 20 10:24:15 summary: changes 0, transients 0 (allowed), syslog 0

Configure Tracing of Commit Scripts

You cannot change the directory (/var/log) to which trace files are written. However, you can customize other trace file settings by including the following statements at the [edit system scripts commit traceoptions] hierarchy level:

[edit system scripts commit traceoptions]
file <filename> <files number> <size size> <world-readable | no-world-readable>;
flag all;
flag events;
flag input;
flag offline;
flag output;
flag rpc;
flag xslt;
no-remote-trace;

These statements are described in the following sections:

Configure the Commit Script Log Filename
Configure the Number and Size of Commit Script Log Files
Configure Access to Commit Script Log Files
Configure the Commit Script Trace Operations

Configure the Commit Script Log Filename

By default, the name of the file that records trace output for commit scripts is cscript.log. You can specify a different name by including the file statement at the [edit system scripts commit traceoptions] hierarchy level:

[edit system scripts commit traceoptions]
file filename;

Configure the Number and Size of Commit Script Log Files

By default, when the trace file reaches 128 KB in size, it is renamed and compressed to filename.0.gz, then filename.1.gz, and so on, until there are 10 trace files. Then the oldest trace file (filename.9.gz) is overwritten.

You can configure the limits on the number and size of trace files by including the following statements at the [edit system scripts commit traceoptions file filename] hierarchy level:

[edit system scripts commit traceoptions file filename]
files number size size;

For example, set the maximum file size to 640 KB and the maximum number of files to 20. When the file that receives the output of the tracing operation (filename) reaches 640 KB, it is renamed and compressed to filename.0.gz, and a new file called filename is created. When filename reaches 640 KB, filename.0.gz is renamed filename.1.gz and filename is renamed and compressed to filename.0.gz. This process repeats until there are 20 trace files. Then the oldest file (filename.19.gz) is overwritten.

The number of files can range from 2 through 1000 files. The file size can range from 10 KB through 1 gigabyte (GB).

Note:

If you set either a maximum file size or a maximum number of trace files, you also must specify the other parameter and a filename.

Configure Access to Commit Script Log Files

By default, access to the commit script log file is restricted to the owner. You can manually configure access by including the world-readable or no-world-readable statement at the [edit system scripts commit traceoptions file filename] hierarchy level.

[edit system scripts commit traceoptions file filename]
(world-readable | no-world-readable);

The no-world-readable statement restricts commit script log access to the owner. The world-readable statement enables unrestricted access to the commit script log file.

Configure the Commit Script Trace Operations

By default, the traceoptions events flag is turned on, regardless of the configuration settings, and only important events are logged. This includes errors, warnings, progress messages, and script processing events. You can configure the trace operations to be logged by including the following statements at the [edit system scripts commit traceoptions] hierarchy level:

[edit system scripts commit traceoptions]
flag all;
flag events;
flag input;
flag offline;
flag output;
flag rpc;
flag xslt;

Table 2 describes the meaning of the commit script tracing flags.

Table 2: Commit Script Tracing Flags
Flag	Description	Default Setting
`all`	Trace all commit script operations.	Off
`events`	Trace important commit script events, including errors, warnings, progress messages, and script processing events.	On
`input`	Trace commit script input data.	Off
`offline`	Generate data for offline development.	Off
`output`	Trace commit script output data.	Off
`rpc`	Trace commit script RPCs.	Off
`xslt`	Trace the Extensible Stylesheet Language Transformations (XSLT) library.	Off

arrow_backward PREVIOUS Display Commit Script Output

NEXT arrow_forward Trace Script Processing on Devices Running Junos OS Evolved

Automation Scripting User Guide

ON THIS PAGE