Run statistics on typed shell commands
Programming Snapshot – Shell Stats

© Lead Image © Scott Rothstein, 123RF.com
In the history log, the Bash shell records all commands typed by the user. Mike Schilli extracts this data with Go for a statistical analysis of his typing behavior.
How did the long command to connect to the database server work again? Shell power users know this memory problem and have taught themselves tricks over the years to repeat or resend modified versions of previously sent command lines. For example, the sequence !!
repeats the last command (useful to prepend a sudo
you might have forgotten); with Ctrl+R you can find and reuse commands that were sent further back in time by using search patterns. Bash remembers the entire typing history and shows it with the history
command, which lists the tail end of what it has in memory (Figure 1).
If you have ever taken a look at the .bash_history
file in your home directory, you will know its little secret. This is where Bash simply appends every command sent, regardless of if it was successful or aborted with an error. If you ask for the last commands you entered, Bash simply looks there (Figure 2).
Timestamp It!
With a small change, Bash not only logs typed commands, but even adds the date and time when the commands were entered. To do this, you need to set the following environment variable (preferably in the .bash_profile
init file):
export HISTTIMEFORMAT="%F %T: "
From then on, Bash adds a comment line with the Unix epoch stamp before each command recorded in the .bash_history
logfile, while the history
command prints the human readable date and time for each command in the display list (Figure 3).

This newly discovered data treasure trove begs for some kind of evaluation, of course. How about determining the days of the week on which a user was most diligent in terms of typing commands? Or how about identifying the most frequently typed commands in order to find new ways to reduce the future typing overhead by using abbreviations or shell scripts?
Callback as an Abstraction
Listing 1 [1] defines the histWalk()
function, which finds the global history logfile for a user in the user's home directory, browses it line by line, and calls a user-provided callback function for each command entry. In this way, other analysis programs can define their own callbacks, pass it to histWalk()
, and receive the history data including timestamps this way, without having to worry about the details of the history logfile's location or format.
Listing 1
histWalk.go
01 package main 02 03 import ( 04 "bufio" 05 "os" 06 "os/user" 07 "path/filepath" 08 "strconv" 09 ) 10 11 func histWalk(cb func(int64, string) error) error { 12 usr, err := user.Current() 13 if err != nil { 14 panic(err) 15 } 16 home := usr.HomeDir 17 histfile := filepath.Join(home, ".bash_history") 18 19 f, err := os.Open(histfile) 20 if err != nil { 21 panic(err) 22 } 23 24 scanner := bufio.NewScanner(f) 25 var timestamp int64 26 for scanner.Scan() { 27 line := scanner.Text() 28 if line[0] == '#' { 29 timestamp, err = strconv.ParseInt(line[1:], 10, 64) 30 if err != nil { 31 panic(err) 32 } 33 } else { 34 err := cb(timestamp, line) 35 if err != nil { 36 return err 37 } 38 } 39 } 40 return nil 41 }
The logfile opened for reading in line 19 by os.Open()
is read line-by-line by the scanner created in line 24. To do so, it grabs the reader interface of the opened file, which is offered via the File
structure, and takes in a new line with every call to Scan()
; scanner.Text()
then returns the text line as a string.
If the line starts with a comment character, it is a timestamp for a command in the subsequent log line. Accordingly, Listing 1 stores the seconds field in the timestamp
variable (after cutting off the leading comment character) and sends the scanner off into the next round. If there is no hash sign at the beginning, it is a command line, and the program jumps to the else
branch starting in line 34, where it calls the callback function entered by the user. As parameters, it passes in the previously saved timestamp and the currently read shell command.
First Class Functions
In Go, functions are first class citizens: They can be assigned to arbitrary variables or passed into other functions in parameter lists. For example, user programs can use the histWalk()
function offered by Listing 1, assign it a callback function that is completely adapted to their special needs, and let it fill existing data structures in the local scope with the results.
The program logic should be easy peasy moving forward. Because of Go's strict typing, however, converting the previously read time value in seconds into an integer can try your patience, because the scanner reads it as a string. The ParseInt()
function from the standard strconv package expects the string to be parsed as its parameter (line[1:]
in line 29 cuts off the first letter – that is, the comment character), as well as the base of the integer number (10
for a decimal number) and the maximum number of bits (64
). Back comes a int64
type value; this is an important detail: Otherwise the lights would go out on January 19, 2038, because by that date the supply of 32-bit integers for the seconds is exhausted.
One use for the histWalk()
function is shown in Listing 2, which runs an analysis of the user's typing activities, broken down for the days of the week (Figure 4). Since the timestamp (stamp
) passed to the callback is an integer, the standard time.Unix()
function called in line 12 easily converts it to the Go internal time.Time
format for time and date values. The Weekday()
function called with the converted value then determines the day of the week for the given date. The int()
wrapper converts the value that exists as a structure in Go's standard time
package into an integer between
(Sunday) and 6
(Saturday).
Listing 2
dow.go
01 package main 02 03 import ( 04 "fmt" 05 "time" 06 ) 07 08 func main() { 09 var countByDoW [7]int 10 11 err := histWalk(func(stamp int64, line string) error { 12 dt := time.Unix(stamp, 0) 13 countByDoW[int(dt.Weekday())]++ 14 return nil 15 }) 16 17 if err != nil { 18 panic(err) 19 } 20 21 for dow := 0; dow < len(countByDoW); dow++ { 22 dowStr := time.Weekday(dow).String() 23 fmt.Printf("%s: %v\n", dowStr, countByDoW[dow]) 24 } 25 }
Buy this article as PDF
(incl. VAT)
Buy Linux Magazine
Direct Download
Read full article as PDF:
Price $2.95
Subscribe to our Linux Newsletters
Find Linux and Open Source Jobs
Subscribe to our ADMIN Newsletters
Find SysAdmin Jobs
News
-
Ubuntu Flatpak Remix Adds Flatpak Support Preinstalled
If you're looking for a version of Ubuntu that includes Flatpak support out of the box, there's one clear option.
-
Gnome 44 Release Candidate Now Available
The Gnome 44 release candidate has officially arrived and adds a few changes into the mix.
-
Flathub Vying to Become the Standard Linux App Store
If the Flathub team has any say in the matter, their product will become the default tool for installing Linux apps in 2023.
-
Debian 12 to Ship with KDE Plasma 5.27
The Debian development team has shifted to the latest version of KDE for their testing branch.
-
Planet Computers Launches ARM-based Linux Desktop PCs
The firm that originally released a line of mobile keyboards has taken a different direction and has developed a new line of out-of-the-box mini Linux desktop computers.
-
Ubuntu No Longer Shipping with Flatpak
In a move that probably won’t come as a shock to many, Ubuntu and all of its official spins will no longer ship with Flatpak installed.
-
openSUSE Leap 15.5 Beta Now Available
The final version of the Leap 15 series of openSUSE is available for beta testing and offers only new software versions.
-
Linux Kernel 6.2 Released with New Hardware Support
Find out what's new in the most recent release from Linus Torvalds and the Linux kernel team.
-
Kubuntu Focus Team Releases New Mini Desktop
The team behind Kubuntu Focus has released a new NX GEN 2 mini desktop PC powered by Linux.
-
KDE Plasma 5.27 Slated for a Valentine's Day Release
The next version of the KDE Plasma desktop is prepped and ready with numerous improvements and plenty of bug fixes.