Bash Script Logging with Timestamp: A Simple Guide for 2025

Logging is an essential part of any script, especially when you want to track its execution over time. It becomes even more crucial when working with Bash scripts. Why? Because logs help you understand what happened, when it happened, and how it happened. One of the best ways to improve your Bash scripts is by adding timestamps to your logs. In this article, we'll walk through how to set up Bash script logging with timestamps, complete with examples and tips to ensure you get the most out of your logs.

Why is Logging Important in Bash Scripts?

When writing Bash scripts, logging serves as a record-keeping tool. Whether you're debugging an issue or simply keeping track of script activities, logging provides insight into the flow of execution. Without logging, you would be left in the dark about the inner workings of your script. You wouldn't know when specific actions happened or what went wrong if there were errors. Logging also helps you monitor script performance, especially when running critical or long-running tasks.

Adding timestamps to your log entries gives you an extra level of detail. It ensures that you not only know what happened, but also when it happened. This is especially useful for troubleshooting and understanding how long certain operations take. So, let’s get started with adding timestamps to your Bash script logs!

How to Add a Timestamp to a Bash Script Log

There are several ways to add timestamps to your logs in a Bash script. The simplest method uses the `date` command, which allows you to include the current date and time in your log entries. Here's how you can do that:

#!/bin/bash

# Define log file
LOG_FILE="/path/to/logfile.log"

# Get the current timestamp
timestamp=$(date "+%Y-%m-%d %H:%M:%S")

# Log message with timestamp
echo "$timestamp - Script started" >> $LOG_FILE

In this script, we're using the `date` command to format the current date and time. The `+%Y-%m-%d %H:%M:%S` format outputs the date and time in a readable format: Year-Month-Day Hour:Minute:Second. Then, we append the timestamp along with the log message to the `LOG_FILE` using the `echo` command.

Example: Logging Script Events with Timestamps

Now that you know how to add a timestamp, let’s see a more practical example. Imagine you have a script that performs a few different tasks, such as checking disk space, backing up files, and cleaning temporary files. You want to log each of these events with timestamps so that you can keep track of when each task occurred.

#!/bin/bash

# Define log file
LOG_FILE="/path/to/logfile.log"

# Get the current timestamp
timestamp=$(date "+%Y-%m-%d %H:%M:%S")

# Log message with timestamp
echo "$timestamp - Checking disk space..." >> $LOG_FILE
df -h >> $LOG_FILE

timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo "$timestamp - Starting backup process..." >> $LOG_FILE
cp -r /source /backup >> $LOG_FILE

timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo "$timestamp - Cleaning temporary files..." >> $LOG_FILE
rm -rf /tmp/* >> $LOG_FILE

timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo "$timestamp - Script finished" >> $LOG_FILE

In this example, we log each major event in the script. Every time we call a command like `df -h` or `cp -r`, we include a timestamp to mark when that event occurred. This way, if there’s an issue or you want to check the execution order, you can easily see the sequence of events and how long each task took.

How to Use Timestamps for Debugging

One of the best features of adding timestamps to your logs is that they can help you debug your script. For example, let’s say you have a script that’s running longer than expected. If you’re logging the timestamps for each event, you’ll be able to see exactly where the delay is happening. You can even calculate the duration of each step to identify bottlenecks.

Here’s an example of how you might use timestamps for debugging:

#!/bin/bash

# Define log file
LOG_FILE="/path/to/logfile.log"

# Get the current timestamp
timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo "$timestamp - Starting backup process..." >> $LOG_FILE

# Log the start time for backup
start_time=$(date +%s)
cp -r /source /backup >> $LOG_FILE

# Log the end time for backup
end_time=$(date +%s)
elapsed_time=$((end_time - start_time))

timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo "$timestamp - Backup finished. Time taken: $elapsed_time seconds" >> $LOG_FILE

In this modified script, we use `date +%s` to get the current time in seconds since the Unix epoch. By capturing the start and end times of the backup process, we can calculate how long the operation took and log that information. This is helpful when debugging performance issues, as it gives you a clear picture of the time spent on each task.

Advanced Logging: Using Log Rotation

If your script runs frequently or generates a lot of logs, you may end up with massive log files that are hard to manage. To solve this problem, you can implement log rotation. Log rotation involves periodically renaming old log files and starting a fresh one to avoid one large, unwieldy file.

Here’s how you can implement log rotation with timestamps:

#!/bin/bash

# Define log file
LOG_FILE="/path/to/logfile.log"
ROTATED_LOG_FILE="/path/to/logfile_$(date +%Y-%m-%d).log"

# Check if log rotation is needed (e.g., if file size exceeds 10MB)
if [ -f $LOG_FILE ] && [ $(stat -c %s $LOG_FILE) -gt 10485760 ]; then
    mv $LOG_FILE $ROTATED_LOG_FILE
    touch $LOG_FILE
    echo "Log rotated: $LOG_FILE renamed to $ROTATED_LOG_FILE"
fi

# Log something
timestamp=$(date "+%Y-%m-%d %H:%M:%S")
echo "$timestamp - Example log entry" >> $LOG_FILE

In this script, we check if the log file has exceeded a certain size (10MB in this case). If it has, we rename the current log file with a timestamp and start a new one. This way, you can keep track of logs without worrying about the file growing too large.

Conclusion

Adding timestamps to your Bash script logs is an excellent way to track script execution, debug issues, and improve overall monitoring. By using the `date` command in your scripts, you can easily add time-based logging to your Bash workflows. Whether you're simply recording script events or tracking performance metrics, timestamps make your logs more meaningful and actionable. Remember to consider log rotation if your scripts generate a lot of output, and always test your scripts to ensure your logging is working as expected. Happy scripting!