Run statistics on typed shell commands
Programming Snapshot – Shell Stats
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
Subscribe to our Linux Newsletters
Find Linux and Open Source Jobs
Subscribe to our ADMIN Newsletters
Support Our Work
Linux Magazine content is made possible with support from readers like you. Please consider contributing when you’ve found an article to be beneficial.
News
-
Thousands of Linux Servers Infected with Stealth Malware Since 2021
Perfctl is capable of remaining undetected, which makes it dangerous and hard to mitigate.
-
Halcyon Creates Anti-Ransomware Protection for Linux
As more Linux systems are targeted by ransomware, Halcyon is stepping up its protection.
-
Valve and Arch Linux Announce Collaboration
Valve and Arch have come together for two projects that will have a serious impact on the Linux distribution.
-
Hacker Successfully Runs Linux on a CPU from the Early ‘70s
From the office of "Look what I can do," Dmitry Grinberg was able to get Linux running on a processor that was created in 1971.
-
OSI and LPI Form Strategic Alliance
With a goal of strengthening Linux and open source communities, this new alliance aims to nurture the growth of more highly skilled professionals.
-
Fedora 41 Beta Available with Some Interesting Additions
If you're a Fedora fan, you'll be excited to hear the beta version of the latest release is now available for testing and includes plenty of updates.
-
AlmaLinux Unveils New Hardware Certification Process
The AlmaLinux Hardware Certification Program run by the Certification Special Interest Group (SIG) aims to ensure seamless compatibility between AlmaLinux and a wide range of hardware configurations.
-
Wind River Introduces eLxr Pro Linux Solution
eLxr Pro offers an end-to-end Linux solution backed by expert commercial support.
-
Juno Tab 3 Launches with Ubuntu 24.04
Anyone looking for a full-blown Linux tablet need look no further. Juno has released the Tab 3.
-
New KDE Slimbook Plasma Available for Preorder
Powered by an AMD Ryzen CPU, the latest KDE Slimbook laptop is powerful enough for local AI tasks.