How to use the command 'script' (with examples)

The script command is a simple yet powerful utility used in Unix-based systems to capture a terminal session’s output. By recording the interactions within the terminal, script allows users to save their session activities to a file, which can later serve as a record for debugging, training, or documentation purposes. Below, we explore various use cases of the script command, demonstrating its versatility in different scenarios.

Use case 1: Record a new session to a file named typescript in the current directory

Code:

script

Motivation: The default usage of script is great for quickly starting a recording without specifying a particular output file path or name. This approach is useful for casual users or quick tasks where immediate capture is more important than file organization. If you frequently check terminal outputs and want a quick way to retain proof or automate reviews, initiating script with the default settings can save time and effort.

Explanation:

• Running the command script without any arguments starts logging all terminal activity to a file named typescript in the current working directory.
• It is a straightforward way to begin capturing session data, enabling users to start recording with minimal setup.

Example Output: After running the command, all subsequent terminal activities are recorded. For example, if you list files in the directory with ls and then check the file typescript, you’ll see that the command and its output are logged there.

Use case 2: Record a new session to a custom filepath

Code:

script path/to/session.out

Motivation: Specifying a custom file path when using script helps organize recorded session files, making it easier to manage and locate them later. This is especially beneficial in a collaborative environment where multiple records need to be stored under a structured directory hierarchy or when specific naming conventions are required as part of the documentation process.

Explanation:

• script is followed by the desired file path (path/to/session.out). This command directs the output to a custom destination file, making it flexible for organizing projects or system administration tasks.

Example Output: Executing this command creates a file at the specified path. Running a command like echo "Hello World" after initializing will include “Hello World” in the session.out file at the designated directory.

Use case 3: Record a new session, appending to an existing file

Code:

script -a path/to/session.out

Motivation: Appending to an existing script file is useful when you want to continuously update logs without overwriting previous content. This approach is perfect for ongoing tasks where new session data should be cumulative, such as logging configuration changes over time or recording progressive stages of a troubleshooting scenario.

Explanation:

• The -a flag instructs script to append new data to the given file path instead of overwriting it, protecting past records while allowing new entries.

Example Output: If the file session.out already contains content from previous commands, running new commands after executing this line would add these to the existing file, preserving the historical data.

Use case 4: Record timing information (data is outputted to stderr)

Code:

script -t 2> path/to/timing_file

Motivation: Including timing information for recorded sessions is invaluable for performance analysis, process evaluations, or complex debugging tasks where understanding the timing and sequence of operations is crucial. This use case is ideal for developers or system administrators who need to assess how long specific commands or operations take within the terminal session.

Explanation:

• The -t option captures timing data of the commands executed and sends the timing output to standard error (2> redirects this error stream), while the > path/to/timing_file indicates where this output should be stored.

Example Output: The timing_file contains precise time stamps for each command entered during the session, providing insights into their execution duration and order.

Use case 5: Write out data as soon as it happens

Code:

script -f path/to/file

Motivation: The ability to flush output immediately is important in scenarios involving live monitoring or real-time analysis, ensuring that the data recorded remains current and up-to-date. This use cases benefits anyone requiring instantaneous feedback from a terminal session, particularly during critical operations or live demonstrations.

Explanation:

• The -f flag enables immediate flushing of the output buffer, ensuring that all session data is written directly to the file specified (path/to/file) without delay.

Example Output: The file is updated with every command and its output as soon as they occur during the session, allowing observers or automated systems to access the freshest data available.

Conclusion:

The script command is a versatile utility for efficiently recording terminal sessions. By offering various options to customize how and where session data is stored, script can be adapted to suit a wide range of user needs, from simple recordings to complex, time-sensitive logging tasks. Understanding and utilizing these options enhances the command’s effectiveness, making it a crucial tool in any Unix-based environment.