When working with compressed log files in Linux/Unix environments, we often need to quickly inspect either the beginning or end of files to verify their time ranges or check recent entries. While zcat | head is commonly used for viewing the start of files, extracting just the final line presents unique challenges with gzip compression.

Gzip compression works linearly from start to finish, which means traditional tools like tail can't directly access the end without processing the entire file. However, we can work around this limitation with several approaches:

The simplest approach combines decompression with tail:

zcat file.log.gz | tail -n 1

While this works, it decompresses the entire file, which is inefficient for large files.

For better performance on multi-core systems, use pigz (parallel gzip):

pigz -dc file.log.gz | tail -n 1

The -d flag decompresses and -c writes to stdout.

When you need to both check the end and potentially browse the file:

zless file.log.gz

Then press Shift+G to jump to the end.

If you know specific patterns in the last line:

zcat file.log.gz | grep "pattern" | tail -n 1

For extremely large files (10GB+), consider these optimizations:

zcat massive.log.gz | tail -n 1000 | tail -n 1

This reduces the pipeline's memory footprint by working with smaller chunks.

Some specialized tools can help:

• zstd - Modern compression with better random access
• lesspipe - Enhanced less functionality for compressed files

To process multiple gzipped logs in a directory:

for f in *.gz; do 
  echo -n "$f: "
  zcat "$f" | tail -n 1
done

---

When working with compressed log files in *.gz format, we often need to quickly check their contents without full decompression. While zcat | head works well for inspecting the beginning of files, examining the end requires different approaches.

The most straightforward method combines zcat with tail:

zcat file.log.gz | tail -n 1

This approach:

• Decompresses the file on-the-fly
• Pipes the output to tail
• Returns only the last line (-n 1)

When dealing with massive files, we can use tac (reverse cat) combined with zcat:

zcat file.log.gz | tac | head -n 1

This method:

• Processes the file from end to beginning
• Only needs to decompress until the first line is found
• Is more efficient for very large files

For files with consistent line endings:

zgrep -E '.+$' file.log.gz | tail -n 1

This regex-based approach:

• Matches complete lines
• Filters empty lines
• Still requires full decompression

Each method has trade-offs:

Method	Memory Usage	Speed	Best For
zcat | tail	High	Fast	Small-medium files
zcat | tac	Low	Slow	Very large files
zgrep	Medium	Medium	Structured logs

For batch processing multiple files:

parallel 'echo -n "{}: "; zcat {} | tail -n 1' ::: *.gz

This GNU parallel command:

• Processes files concurrently
• Shows filename with each result
• Works well on multi-core systems