├── .gitignore
├── CONTRIBUTING.md
├── DCO
├── LICENSE
├── README.md
├── assets
    └── images
    │   ├── agg.png
    │   ├── app_coarse.png
    │   ├── app_fine.png
    │   └── thyme.png
├── cmd
    └── thyme
    │   └── main.go
├── darwin.go
├── data.go
├── linux.go
├── list.go
├── release.sh
├── show.go
└── windows.go


/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | .bin
3 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # How to Contribute
 2 | 
 3 | This Sourcegraph project is [MIT licensed](LICENSE) and accepts
 4 | contributions via GitHub pull requests. This document outlines some of
 5 | the conventions on development workflow, commit message formatting,
 6 | contact points and other resources to make it easier to get your
 7 | contribution accepted.
 8 | 
 9 | # Certificate of Origin
10 | 
11 | By contributing to this project you agree to the Developer Certificate of Origin
12 | (DCO). This document was created by the Linux Kernel community and is a simple
13 | statement that you, as a contributor, have the legal right to make the
14 | contribution. See the [DCO](DCO) file for details.
15 | 
16 | ## Getting Started
17 | 
18 | - Fork the repository on GitHub
19 | - Read the [README](README.md) for build and test instructions
20 | - Play with the project, submit bugs, submit patches!
21 | 
22 | ## Contribution Flow
23 | 
24 | This is a rough outline of what a contributor's workflow looks like:
25 | 
26 | - Create a topic branch from where you want to base your work (usually master).
27 | - Make commits of logical units.
28 | - Make sure your commit messages are in the proper format (see below).
29 | - Push your changes to a topic branch in your fork of the repository.
30 | - Make sure the tests pass, and add any new tests as appropriate.
31 | - Submit a pull request to the original repository.
32 | 
33 | Thanks for your contributions!
34 | 
35 | ### Format of the Commit Message
36 | 
37 | We follow a rough convention for commit messages that is designed to answer two
38 | questions: what changed and why. The subject line should feature the what and
39 | the body of the commit should describe the why.
40 | 
41 | ```
42 | scripts: add the test-cluster command
43 | 
44 | this uses tmux to setup a test cluster that you can easily kill and
45 | start for debugging.
46 | 
47 | Fixes #38
48 | ```
49 | 
50 | The format can be described more formally as follows:
51 | 
52 | ```
53 | <subsystem>: <what changed>
54 | <BLANK LINE>
55 | <why this change was made>
56 | <BLANK LINE>
57 | <footer>
58 | ```
59 | 
60 | The first line is the subject and should be no longer than 70 characters, the
61 | second line is always blank, and other lines should be wrapped at 80 characters.
62 | This allows the message to be easier to read on Sourcegraph and GitHub as well
63 | as in various git tools.
64 | 


--------------------------------------------------------------------------------
/DCO:
--------------------------------------------------------------------------------
 1 | Developer Certificate of Origin
 2 | Version 1.1
 3 | 
 4 | Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
 5 | 1 Letterman Drive
 6 | Suite D4700
 7 | San Francisco, CA, 94129
 8 | 
 9 | Everyone is permitted to copy and distribute verbatim copies of this
10 | license document, but changing it is not allowed.
11 | 
12 | 
13 | Developer's Certificate of Origin 1.1
14 | 
15 | By making a contribution to this project, I certify that:
16 | 
17 | (a) The contribution was created in whole or in part by me and I
18 |     have the right to submit it under the open source license
19 |     indicated in the file; or
20 | 
21 | (b) The contribution is based upon previous work that, to the best
22 |     of my knowledge, is covered under an appropriate open source
23 |     license and I have the right under that license to submit that
24 |     work with modifications, whether created in whole or in part
25 |     by me, under the same open source license (unless I am
26 |     permitted to submit under a different license), as indicated
27 |     in the file; or
28 | 
29 | (c) The contribution was provided directly to me by some other
30 |     person who certified (a), (b) or (c) and I have not modified
31 |     it.
32 | 
33 | (d) I understand and agree that this project and the contribution
34 |     are public and that a record of the contribution (including all
35 |     personal information I submit with it, including my sign-off) is
36 |     maintained indefinitely and may be redistributed consistent with
37 |     this project or the open source license(s) involved.
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Sourcegraph
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # <img alt="logo" src="/assets/images/thyme.png" height="40"> Thyme
  2 | 
  3 | Spice up your day-to-day productivity with some free Thyme, courtesy
  4 | of the team at [Sourcegraph](https://sourcegraph.com) (the
  5 | [best way to read and explore code](https://sourcegraph.com/github.com/sourcegraph/thyme/-/def/GoPackage/github.com/sourcegraph/thyme/-/Snapshot)).
  6 | Automatically track which applications you use and for how long.
  7 | 
  8 | - Simple CLI to track and analyze your application usage
  9 | - Detailed charts that let you profile how you spend your time
 10 | - Stores data locally, giving you full control and privacy
 11 | - [Open-source](https://sourcegraph.com/github.com/sourcegraph/thyme/-/def/GoPackage/github.com/sourcegraph/thyme/cmd/thyme/-/main.go/TrackCmd/Execute), [well-documented](https://godoc.org/github.com/sourcegraph/thyme), and easily extensible
 12 | 
 13 | Thyme is a work in progress, so please report bugs! Want to see how it works? [Dive into the source here.](https://sourcegraph.com/github.com/sourcegraph/thyme/-/def/GoPackage/github.com/sourcegraph/thyme/cmd/thyme/-/main.go/TrackCmd/Execute)
 14 | 
 15 | Want to share what you've learned about your Thyme? Join the discussion on [Twitter](https://twitter.com/intent/tweet?url=https%3A%2F%2Fgithub.com%2Fsourcegraph%2Fthyme&original_referer=https%3A%2F%2Fgithub.com).
 16 | 
 17 | ## Features
 18 | 
 19 | ### Simple CLI
 20 | 
 21 | 1. Record which applications you use every 30 seconds:
 22 |    ```
 23 |    $ while true; do thyme track -o thyme.json; sleep 30s; done;
 24 |    ```
 25 | 
 26 | 2. Create charts showing application usage over time. In a new window:
 27 |    ```
 28 |    $ thyme show -i thyme.json -w stats > thyme.html
 29 |    ```
 30 | 
 31 | 3. Open `thyme.html` in your browser of choice to see the charts
 32 |    below.
 33 | 
 34 | ### Application usage timeline
 35 | 
 36 | ![Application usage timeline](/assets/images/app_coarse.png)
 37 | 
 38 | ### Detailed application window timeline
 39 | 
 40 | ![Application usage timeline](/assets/images/app_fine.png)
 41 | 
 42 | ### Aggregate time usage by app
 43 | 
 44 | ![Application usage timeline](/assets/images/agg.png)
 45 | 
 46 | 
 47 | ## Dependencies
 48 | 
 49 | Thyme's dependencies vary by system. See `thyme dep` (mentioned in the installation instructions below).
 50 | 
 51 | ## Install
 52 | 
 53 | 1. [Install Go](https://golang.org/dl/) (if you have Homebrew on macOS, you can also run `brew install go`) and run
 54 |    ```
 55 |    $ go get -u github.com/sourcegraph/thyme/cmd/thyme
 56 |    ```
 57 |    Alternatively, if you don't want to install Go, just download the `thyme` binary [here](https://github.com/sourcegraph/thyme/releases).
 58 | 
 59 | 1. Follow the instructions printed by `thyme dep`.
 60 |    ```
 61 |    $ thyme dep
 62 |    ```
 63 | 
 64 | 1. Verify `thyme` works with
 65 |    ```
 66 |    $ thyme track
 67 |    ```
 68 |    This should display JSON describing which applications are currently active, visible, and present on your system.
 69 | 
 70 | Thyme currently supports Linux, macOS, and Windows.
 71 | 
 72 | ## Usage for Other Shells
 73 | ##### Windows Powershell
 74 |    ```
 75 |    > for(1){thyme track -o thyme.json; Start-Sleep -s 5}
 76 |    > thyme show -i thyme.json -w stats | Out-File -e utf8 thyme.html
 77 |    ```
 78 | ##### Windows DOS Command Line
 79 |    ```
 80 |    > for /L %n in (0) do @(thyme track -o thyme.json && timeout /t 5 /nobreak)
 81 |    > thyme show -i thyme.json -w stats > thyme.html
 82 |    ```
 83 | 
 84 | ## Use cases
 85 | 
 86 | Thyme was designed for developers who want to investigate their
 87 | application usage to make decisions that boost their day-to-day
 88 | productivity.
 89 | 
 90 | It can also be for other purposes such as:
 91 | 
 92 | - Tracking billable hours and constructing timesheets
 93 | - Studying application usage behavior in a given population
 94 | 
 95 | ## How is Thyme different from other time trackers?
 96 | 
 97 | There are many time tracking products and services on the market.
 98 | Thyme differs from available offerings in the following ways:
 99 | 
100 | - Thyme does not intend to be a fully featured time management product
101 |   or service. Thyme adopts the Unix philosophy of a command-line tool
102 |   that does one thing well and plays nicely with other command-line
103 |   tools.
104 | 
105 | - Thyme does not require you to manually signal when you start or stop
106 |   an activity. It automatically records which applications you use.
107 | 
108 | - Thyme is open source and free of charge.
109 | 
110 | - Thyme does not send data over the network. It stores the data it
111 |   collects on local disk. It's up to you whether you want to share it
112 |   or not.
113 | 
114 | ## Attribution
115 | 
116 | The [Thyme logo](https://thenounproject.com/term/thyme/356887/)
117 | <img alt="logo" src="/assets/images/thyme.png" height="40"> by
118 | [Anthony Bossard](https://thenounproject.com/le101edaltonien/) is
119 | licensed under
120 | [Creative Commons 3.0](https://creativecommons.org/licenses/by/3.0/us/).
121 | 


--------------------------------------------------------------------------------
/assets/images/agg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sourcegraph/thyme/6b30af5798bdc7e0388758a0544020aef15d61c7/assets/images/agg.png


--------------------------------------------------------------------------------
/assets/images/app_coarse.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sourcegraph/thyme/6b30af5798bdc7e0388758a0544020aef15d61c7/assets/images/app_coarse.png


--------------------------------------------------------------------------------
/assets/images/app_fine.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sourcegraph/thyme/6b30af5798bdc7e0388758a0544020aef15d61c7/assets/images/app_fine.png


--------------------------------------------------------------------------------
/assets/images/thyme.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sourcegraph/thyme/6b30af5798bdc7e0388758a0544020aef15d61c7/assets/images/thyme.png


--------------------------------------------------------------------------------
/cmd/thyme/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"os"
  8 | 	"runtime"
  9 | 
 10 | 	"github.com/jessevdk/go-flags"
 11 | 	"github.com/sourcegraph/thyme"
 12 | )
 13 | 
 14 | var CLI = flags.NewNamedParser("thyme", flags.PrintErrors|flags.PassDoubleDash)
 15 | 
 16 | func init() {
 17 | 	CLI.Usage = `
 18 | thyme - automatically track which applications you use and for how long.
 19 | 
 20 |   \|//   thyme is a simple time tracker that tracks active window names and collects
 21 |  W Y/    statistics over active, open, and visible windows. Statistics are collected
 22 |   \|  ,  into a local JSON file, which is used to generate a pretty HTML report.
 23 |    \_/
 24 |     \
 25 |      \_  thyme is a local CLI tool and does not send any data over the network.
 26 | 
 27 | Example usage:
 28 | 
 29 |   thyme dep
 30 |   thyme track -o <file>
 31 |   thyme show  -i <file> -w stats > viz.html
 32 | 
 33 | `
 34 | 
 35 | 	if _, err := CLI.AddCommand("track", "record current windows", "Record current window metadata as JSON printed to stdout or a file. If a filename is specified and the file already exists, Thyme will append the new snapshot data to the existing data.", &trackCmd); err != nil {
 36 | 		log.Fatal(err)
 37 | 	}
 38 | 	if _, err := CLI.AddCommand("show", "visualize data", "Generate an HTML page visualizing the data from a file written to by `thyme track`.", &showCmd); err != nil {
 39 | 		log.Fatal(err)
 40 | 	}
 41 | 	if _, err := CLI.AddCommand("dep", "dep install instructions", "Show installation instructions for required external dependencies (which vary depending on your OS and windowing system).", &depCmd); err != nil {
 42 | 		log.Fatal(err)
 43 | 	}
 44 | }
 45 | 
 46 | // TrackCmd is the subcommand that tracks application usage.
 47 | type TrackCmd struct {
 48 | 	Out string `long:"out" short:"o" description:"output file"`
 49 | }
 50 | 
 51 | var trackCmd TrackCmd
 52 | 
 53 | func (c *TrackCmd) Execute(args []string) error {
 54 | 	t, err := getTracker()
 55 | 	if err != nil {
 56 | 		return err
 57 | 	}
 58 | 	snap, err := t.Snap()
 59 | 	if err != nil {
 60 | 		return err
 61 | 	}
 62 | 
 63 | 	if c.Out == "" {
 64 | 		out, err := json.MarshalIndent(snap, "", "  ")
 65 | 		if err != nil {
 66 | 			return err
 67 | 		}
 68 | 		fmt.Println(string(out))
 69 | 	} else {
 70 | 		var stream thyme.Stream
 71 | 		if _, err := os.Stat(c.Out); err == nil {
 72 | 			if err := func() error {
 73 | 				f, err := os.Open(c.Out)
 74 | 				if err != nil {
 75 | 					return err
 76 | 				}
 77 | 				defer f.Close()
 78 | 				if err := json.NewDecoder(f).Decode(&stream); err != nil {
 79 | 					return err
 80 | 				}
 81 | 				return nil
 82 | 			}(); err != nil {
 83 | 				return err
 84 | 			}
 85 | 		} else if !os.IsNotExist(err) {
 86 | 			return err
 87 | 		}
 88 | 		stream.Snapshots = append(stream.Snapshots, snap)
 89 | 		f, err := os.Create(c.Out)
 90 | 		if err != nil {
 91 | 			return err
 92 | 		}
 93 | 		if err := json.NewEncoder(f).Encode(stream); err != nil {
 94 | 			return err
 95 | 		}
 96 | 	}
 97 | 
 98 | 	return nil
 99 | }
100 | 
101 | // ShowCmd is the subcommand that reads the data emitted by the track
102 | // subcommand and displays the data to the user.
103 | type ShowCmd struct {
104 | 	In   string `long:"in" short:"i" description:"input file"`
105 | 	What string `long:"what" short:"w" description:"what to show {list,stats}" default:"list"`
106 | }
107 | 
108 | var showCmd ShowCmd
109 | 
110 | func (c *ShowCmd) Execute(args []string) error {
111 | 	if c.In == "" {
112 | 		var snap thyme.Snapshot
113 | 		if err := json.NewDecoder(os.Stdin).Decode(&snap); err != nil {
114 | 			return err
115 | 		}
116 | 		for _, w := range snap.Windows {
117 | 			fmt.Printf("%+v\n", w.Info())
118 | 		}
119 | 	} else {
120 | 		var stream thyme.Stream
121 | 		f, err := os.Open(c.In)
122 | 		if err != nil {
123 | 			return err
124 | 		}
125 | 		defer f.Close()
126 | 
127 | 		if err := json.NewDecoder(f).Decode(&stream); err != nil {
128 | 			return err
129 | 		}
130 | 		switch c.What {
131 | 		case "stats":
132 | 			if err := thyme.Stats(&stream); err != nil {
133 | 				return err
134 | 			}
135 | 		case "list":
136 | 			fallthrough
137 | 		default:
138 | 			thyme.List(&stream)
139 | 		}
140 | 	}
141 | 	return nil
142 | }
143 | 
144 | type DepCmd struct{}
145 | 
146 | var depCmd DepCmd
147 | 
148 | func (c *DepCmd) Execute(args []string) error {
149 | 	t, err := getTracker()
150 | 	if err != nil {
151 | 		return err
152 | 	}
153 | 	fmt.Println(t.Deps())
154 | 	return nil
155 | }
156 | 
157 | func main() {
158 | 	run := func() error {
159 | 		_, err := CLI.Parse()
160 | 		if err != nil {
161 | 			if _, isFlagsErr := err.(*flags.Error); isFlagsErr {
162 | 				CLI.WriteHelp(os.Stderr)
163 | 				return nil
164 | 			} else {
165 | 				return err
166 | 			}
167 | 		}
168 | 		return nil
169 | 	}
170 | 
171 | 	if err := run(); err != nil {
172 | 		log.Print(err)
173 | 		os.Exit(1)
174 | 	}
175 | }
176 | 
177 | func getTracker() (thyme.Tracker, error) {
178 | 	switch runtime.GOOS {
179 | 	case "windows":
180 | 		return thyme.NewTracker("windows"), nil
181 | 	case "darwin":
182 | 		return thyme.NewTracker("darwin"), nil
183 | 	default:
184 | 		return thyme.NewTracker("linux"), nil
185 | 	}
186 | }
187 | 


--------------------------------------------------------------------------------
/darwin.go:
--------------------------------------------------------------------------------
  1 | package thyme
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"hash/fnv"
  7 | 	"log"
  8 | 	"os/exec"
  9 | 	"strconv"
 10 | 	"strings"
 11 | 	"time"
 12 | )
 13 | 
 14 | func init() {
 15 | 	RegisterTracker("darwin", NewDarwinTracker)
 16 | }
 17 | 
 18 | // DarwinTracker tracks application usage using the "System Events" API in AppleScript. Due to the liminations of this
 19 | // API, the DarwinTracker will not be able to detect individual windows of applications that are not scriptable (in the
 20 | // AppleScript sense). For these applications, a single window is emitted with the name set to the application process
 21 | // name and the ID set to the process ID.
 22 | type DarwinTracker struct{}
 23 | 
 24 | var _ Tracker = (*DarwinTracker)(nil)
 25 | 
 26 | func NewDarwinTracker() Tracker {
 27 | 	return &DarwinTracker{}
 28 | }
 29 | 
 30 | // allWindowsScript fetches the windows of all scriptable applications.  It
 31 | // iterates through each application process known to System Events and attempts
 32 | // to script the application with the same name as the application process. If
 33 | // such an application exists and is scriptable, it prints the name of every
 34 | // window in the application. Otherwise, it just prints the name of every
 35 | // visible window in the application. If no visible windows exist, it will just
 36 | // print the application name.  (System Events processes only have windows in
 37 | // the current desktop/workspace.)
 38 | const (
 39 | 	allWindowsScript = `
 40 | tell application "System Events"
 41 |   set listOfProcesses to (every application process where background only is false)
 42 | end tell
 43 | 
 44 | repeat with proc in listOfProcesses
 45 |   set procName to (name of proc)
 46 |   set procID to (id of proc)
 47 |   log "PROCESS " & procID & ":" & procName
 48 |   -- Attempt to list windows if the process is scriptable
 49 |   try
 50 |     tell application procName
 51 |       repeat with i from 1 to (count windows)
 52 |         log "WINDOW " & (id of window i) & ":" & (name of window i) as string
 53 |       end repeat
 54 |     end tell
 55 |   end try
 56 | end repeat
 57 | `
 58 | 	activeWindowsScript = `
 59 | tell application "System Events"
 60 |      set proc to (first application process whose frontmost is true)
 61 | end tell
 62 | 
 63 | set procName to (name of proc)
 64 | try
 65 |   tell application procName
 66 |      log "WINDOW " & (id of window 1) & ":" & (name of window 1)
 67 |   end tell
 68 | on error e
 69 |   log "WINDOW " & (id of proc) & ":" & (name of first window of proc)
 70 | end try
 71 | `
 72 | 	// visibleWindowsScript generates a mapping from process to windows in the
 73 | 	// current desktop (note: this is slightly different than the behavior of
 74 | 	// the previous two scripts, where an empty windows list for a process
 75 | 	// should NOT imply that there is one window named after the process.
 76 | 	// Furthermore, the window IDs are not valid in this script (only the window
 77 | 	// name is valid).
 78 | 	visibleWindowsScript = `
 79 | tell application "System Events"
 80 | 	set listOfProcesses to (every process whose visible is true)
 81 | end tell
 82 | repeat with proc in listOfProcesses
 83 | 	set procName to (name of proc)
 84 | 	set procID to (id of proc)
 85 | 	log "PROCESS " & procID & ":" & procName
 86 | 	set app_windows to (every window of proc)
 87 | 	repeat with each_window in app_windows
 88 | 		log "WINDOW -1:" & (name of each_window) as string
 89 | 	end repeat
 90 | end repeat
 91 | `
 92 | )
 93 | 
 94 | func (t *DarwinTracker) Deps() string {
 95 | 	return `
 96 | You will need to enable privileges for "Terminal" in System Preferences > Security & Privacy > Privacy > Accessibility.
 97 | See https://support.apple.com/en-us/HT202802 for details.
 98 | 
 99 | Note: this command prints out this message regardless of whether this has been done or not.
100 | `
101 | }
102 | 
103 | func (t *DarwinTracker) Snap() (*Snapshot, error) {
104 | 	var allWindows []*Window
105 | 	var allProcWins map[process][]*Window
106 | 	{
107 | 		procWins, err := runAS(allWindowsScript)
108 | 		if err != nil {
109 | 			return nil, err
110 | 		}
111 | 		for proc, wins := range procWins {
112 | 			if len(wins) == 0 {
113 | 				allWindows = append(allWindows, &Window{ID: proc.id, Name: proc.name})
114 | 			} else {
115 | 				allWindows = append(allWindows, wins...)
116 | 			}
117 | 		}
118 | 		allProcWins = procWins
119 | 	}
120 | 
121 | 	var active int64
122 | 	{
123 | 		procWins, err := runAS(activeWindowsScript)
124 | 		if err != nil {
125 | 			return nil, err
126 | 		}
127 | 		if len(procWins) > 1 {
128 | 			return nil, fmt.Errorf("found more than one active process: %+v", procWins)
129 | 		}
130 | 		for proc, wins := range procWins {
131 | 			if len(wins) == 0 {
132 | 				active = proc.id
133 | 			} else if len(wins) == 1 {
134 | 				active = wins[0].ID
135 | 			} else {
136 | 				return nil, fmt.Errorf("found more than one active window: %+v", wins)
137 | 			}
138 | 		}
139 | 	}
140 | 
141 | 	var visible []int64
142 | 	{
143 | 		procWins, err := runAS(visibleWindowsScript)
144 | 		if err != nil {
145 | 			return nil, err
146 | 		}
147 | 		for proc, wins := range procWins {
148 | 			allWins := allProcWins[proc]
149 | 			for _, visWin := range wins {
150 | 				if len(allWins) == 0 {
151 | 					visible = append(visible, proc.id)
152 | 				} else {
153 | 					found := false
154 | 					for _, win := range allWins {
155 | 						if win.Name == visWin.Name {
156 | 							visible = append(visible, win.ID)
157 | 							found = true
158 | 							break
159 | 						}
160 | 					}
161 | 					if !found {
162 | 						log.Printf("warning: window ID not found for visible window %q", visWin.Name)
163 | 					}
164 | 				}
165 | 			}
166 | 		}
167 | 	}
168 | 
169 | 	return &Snapshot{
170 | 		Time:    time.Now(),
171 | 		Windows: allWindows,
172 | 		Active:  active,
173 | 		Visible: visible,
174 | 	}, nil
175 | }
176 | 
177 | // process is the {name, id} of a process
178 | type process struct {
179 | 	name string
180 | 	id   int64
181 | }
182 | 
183 | // runAS runs script as AppleScript and parses the output into a map of
184 | // processes to windows.
185 | func runAS(script string) (map[process][]*Window, error) {
186 | 	cmd := exec.Command("osascript")
187 | 	cmd.Stdin = bytes.NewBuffer([]byte(script))
188 | 	b, err := cmd.CombinedOutput()
189 | 	if err != nil {
190 | 		return nil, fmt.Errorf("AppleScript error: %s, output was:\n%s", err, string(b))
191 | 	}
192 | 	return parseASOutput(string(b))
193 | }
194 | 
195 | // parseASOutput parses the output of the AppleScript snippets used to extract window information.
196 | func parseASOutput(out string) (map[process][]*Window, error) {
197 | 	proc := process{}
198 | 	procWins := make(map[process][]*Window)
199 | 	for _, line := range strings.Split(out, "\n") {
200 | 		if strings.HasPrefix(line, "PROCESS ") {
201 | 			c := strings.Index(line, ":")
202 | 			procID, err := strconv.ParseInt(line[len("PROCESS "):c], 10, 0)
203 | 			if err != nil {
204 | 				return nil, err
205 | 			}
206 | 			proc = process{line[c+1:], procID}
207 | 			procWins[proc] = nil
208 | 		} else if strings.HasPrefix(line, "WINDOW ") {
209 | 			win, winID := parseWindowLine(line, proc.id)
210 | 			procWins[proc] = append(procWins[proc],
211 | 				&Window{ID: winID, Name: fmt.Sprintf("%s - %s", win, proc.name)},
212 | 			)
213 | 		}
214 | 	}
215 | 	return procWins, nil
216 | }
217 | 
218 | // parseWindowLine parses window ID from a line of the AppleScript
219 | // output. If the ID is missing ("missing value"), parseWindowLine
220 | // will return the hash of the window title and process ID. Note: if 2
221 | // windows controlled by the same process both have IDs missing and
222 | // have the same title, they will hash to the same ID. This is
223 | // unfortunate but seems to be the best behavior.
224 | func parseWindowLine(line string, procId int64) (string, int64) {
225 | 	c := strings.Index(line, ":")
226 | 	win := line[c+1:]
227 | 	winID, err := strconv.ParseInt(line[len("WINDOW "):c], 10, 0)
228 | 	if err != nil {
229 | 		// sometimes "missing value" appears here, so generate a value
230 | 		// taking the process ID and the window index to generate a hash
231 | 		winID = hash(fmt.Sprintf("%s%v", win, procId))
232 | 	}
233 | 	return win, winID
234 | }
235 | 
236 | // hash converts a string to an integer hash
237 | func hash(s string) int64 {
238 | 	h := fnv.New32a()
239 | 	h.Write([]byte(s))
240 | 	return int64(h.Sum32())
241 | }
242 | 


--------------------------------------------------------------------------------
/data.go:
--------------------------------------------------------------------------------
  1 | package thyme
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"strings"
  8 | 	"time"
  9 | )
 10 | 
 11 | // trackers is the list of Tracker constructors that are available on this system. Tracker implementations should call
 12 | // the RegisterTracker function to make themselves available.
 13 | var trackers = make(map[string]func() Tracker)
 14 | 
 15 | // RegisterTracker makes a Tracker constructor available to clients of this package.
 16 | func RegisterTracker(name string, t func() Tracker) {
 17 | 	if _, exists := trackers[name]; exists {
 18 | 		log.Fatalf("a tracker already exists with the name %s", name)
 19 | 	}
 20 | 	trackers[name] = t
 21 | }
 22 | 
 23 | // NewTracker returns a new Tracker instance whose type is `name`.
 24 | func NewTracker(name string) Tracker {
 25 | 	if _, exists := trackers[name]; !exists {
 26 | 		log.Fatalf("no Tracker constructor has been registered with name %s", name)
 27 | 	}
 28 | 	return trackers[name]()
 29 | }
 30 | 
 31 | // Tracker tracks application usage. An implementation that satisfies
 32 | // this interface is required for each OS windowing system Thyme
 33 | // supports.
 34 | type Tracker interface {
 35 | 	// Snap returns a Snapshot reflecting the currently in-use windows
 36 | 	// at the current time.
 37 | 	Snap() (*Snapshot, error)
 38 | 
 39 | 	// Deps returns a string listing the dependencies that still need
 40 | 	// to be installed with instructions for how to install them.
 41 | 	Deps() string
 42 | }
 43 | 
 44 | // Stream represents all the sampling data gathered by Thyme.
 45 | type Stream struct {
 46 | 	// Snapshots is a list of window snapshots ordered by time.
 47 | 	Snapshots []*Snapshot
 48 | }
 49 | 
 50 | // Print returns a pretty-printed representation of the snapshot.
 51 | func (s Stream) Print() string {
 52 | 	var b bytes.Buffer
 53 | 	for _, snap := range s.Snapshots {
 54 | 		fmt.Fprintf(&b, "%s", snap.Print())
 55 | 	}
 56 | 	return string(b.Bytes())
 57 | }
 58 | 
 59 | // Snapshot represents the current state of all in-use application
 60 | // windows at a moment in time.
 61 | type Snapshot struct {
 62 | 	Time    time.Time
 63 | 	Windows []*Window
 64 | 	Active  int64
 65 | 	Visible []int64
 66 | }
 67 | 
 68 | // Print returns a pretty-printed representation of the snapshot.
 69 | func (s Snapshot) Print() string {
 70 | 	var b bytes.Buffer
 71 | 
 72 | 	var active *Window
 73 | 	visible := make([]*Window, 0, len(s.Windows))
 74 | 	other := make([]*Window, 0, len(s.Windows))
 75 | s_Windows:
 76 | 	for _, w := range s.Windows {
 77 | 		if w.ID == s.Active {
 78 | 			active = w
 79 | 			continue s_Windows
 80 | 		}
 81 | 		for _, v := range s.Visible {
 82 | 			if w.ID == v {
 83 | 				visible = append(visible, w)
 84 | 				continue s_Windows
 85 | 			}
 86 | 		}
 87 | 		other = append(other, w)
 88 | 	}
 89 | 
 90 | 	fmt.Fprintf(&b, "%s\n", s.Time.Format("Mon Jan 2 15:04:05 -0700 MST 2006"))
 91 | 	if active != nil {
 92 | 		fmt.Fprintf(&b, "\tActive: %s\n", active.Info().Print())
 93 | 	}
 94 | 	if len(visible) > 0 {
 95 | 		fmt.Fprintf(&b, "\tVisible: ")
 96 | 		for _, v := range visible {
 97 | 			fmt.Fprintf(&b, "%s, ", v.Info().Print())
 98 | 		}
 99 | 		fmt.Fprintf(&b, "\n")
100 | 	}
101 | 	if len(other) > 0 {
102 | 		fmt.Fprintf(&b, "\tOther: ")
103 | 		for _, w := range other {
104 | 			fmt.Fprintf(&b, "%s, ", w.Info().Print())
105 | 		}
106 | 		fmt.Fprintf(&b, "\n")
107 | 	}
108 | 	return string(b.Bytes())
109 | }
110 | 
111 | // Window represents an application window.
112 | type Window struct {
113 | 	// ID is the numerical identifier of the window.
114 | 	ID int64
115 | 
116 | 	// Desktop is the numerical identifier of the desktop the
117 | 	// window belongs to.  Equal to -1 if the window is sticky.
118 | 	Desktop int64
119 | 
120 | 	// Name is the display name of the window (typically what the
121 | 	// windowing system shows in the top bar of the window).
122 | 	Name string
123 | }
124 | 
125 | // systemNames is a set of excluded window names that are known to
126 | // be used by system windows that aren't visible to the user.
127 | var systemNames = map[string]struct{}{
128 | 	"XdndCollectionWindowImp": {},
129 | 	"unity-launcher":          {},
130 | 	"unity-panel":             {},
131 | 	"unity-dash":              {},
132 | 	"Hud":                     {},
133 | 	"Desktop":                 {},
134 | }
135 | 
136 | // IsSystem returns true if the window is a system window (like
137 | // "unity-panel" and thus shouldn't be considered an application
138 | // visible to the end-users)
139 | func (w *Window) IsSystem() bool {
140 | 	if _, is := systemNames[w.Name]; is {
141 | 		return true
142 | 	}
143 | 	return false
144 | }
145 | 
146 | // IsSticky returns true if the window is a sticky window (i.e.
147 | // present on all desktops)
148 | func (w *Window) IsSticky() bool {
149 | 	return w.Desktop == -1
150 | }
151 | 
152 | // IsOnDesktop returns true if the window is present on the specified
153 | // desktop
154 | func (w *Window) IsOnDesktop(desktop int64) bool {
155 | 	return w.IsSticky() || w.Desktop == desktop
156 | }
157 | 
158 | const (
159 | 	defaultWindowTitleSeparator       = " - "
160 | 	microsoftEdgeWindowTitleSeparator = "\u200e- "
161 | )
162 | 
163 | // Info returns more structured metadata about a window. The metadata
164 | // is extracted using heuristics.
165 | //
166 | // Assumptions:
167 | //     1) Most windows use " - " to separate their window names from their content
168 | //     2) Most windows use the " - " with the application name at the end.
169 | //     3) The few programs that reverse this convention only reverse it.
170 | func (w *Window) Info() *Winfo {
171 | 	// Special Cases
172 | 	fields := strings.Split(w.Name, defaultWindowTitleSeparator)
173 | 	if len(fields) > 1 {
174 | 		last := strings.TrimSpace(fields[len(fields)-1])
175 | 		if last == "Google Chrome" {
176 | 			return &Winfo{
177 | 				App:    "Google Chrome",
178 | 				SubApp: strings.TrimSpace(fields[len(fields)-2]),
179 | 				Title:  strings.Join(fields[0:len(fields)-2], defaultWindowTitleSeparator),
180 | 			}
181 | 		}
182 | 	}
183 | 
184 | 	if strings.Contains(w.Name, microsoftEdgeWindowTitleSeparator) {
185 | 		// App Name Last
186 | 		beforeSep := strings.LastIndex(w.Name, microsoftEdgeWindowTitleSeparator)
187 | 		afterSep := beforeSep + len(microsoftEdgeWindowTitleSeparator)
188 | 		return &Winfo{
189 | 			App:   strings.TrimSpace(w.Name[afterSep:]),
190 | 			Title: strings.TrimSpace(w.Name[:beforeSep]),
191 | 		}
192 | 	}
193 | 
194 | 	// Normal Cases
195 | 	if beforeSep := strings.Index(w.Name, defaultWindowTitleSeparator); beforeSep > -1 {
196 | 		// App Name First
197 | 		if w.Name[:beforeSep] == "Slack" {
198 | 			afterSep := beforeSep + len(defaultWindowTitleSeparator)
199 | 			return &Winfo{
200 | 				App:   strings.TrimSpace(w.Name[:beforeSep]),
201 | 				Title: strings.TrimSpace(w.Name[afterSep:]),
202 | 			}
203 | 		}
204 | 
205 | 		// App Name Last
206 | 		beforeSep := strings.LastIndex(w.Name, defaultWindowTitleSeparator)
207 | 		afterSep := beforeSep + len(defaultWindowTitleSeparator)
208 | 		return &Winfo{
209 | 			App:   strings.TrimSpace(w.Name[afterSep:]),
210 | 			Title: strings.TrimSpace(w.Name[:beforeSep]),
211 | 		}
212 | 	}
213 | 
214 | 	// No Application name separator
215 | 	return &Winfo{
216 | 		Title: w.Name,
217 | 	}
218 | }
219 | 
220 | // Winfo is structured metadata info about a window.
221 | type Winfo struct {
222 | 	// App is the application that controls the window.
223 | 	App string
224 | 
225 | 	// SubApp is the sub-application that controls the window. An
226 | 	// example is a web app (e.g., Sourcegraph) that runs
227 | 	// inside a Chrome tab. In this case, the App field would be
228 | 	// "Google Chrome" and the SubApp field would be "Sourcegraph".
229 | 	SubApp string
230 | 
231 | 	// Title is the title of the window after the App and SubApp name
232 | 	// have been stripped.
233 | 	Title string
234 | }
235 | 
236 | // Print returns a pretty-printed representation of the snapshot.
237 | func (w Winfo) Print() string {
238 | 	return fmt.Sprintf("[%s|%s|%s]", w.App, w.SubApp, w.Title)
239 | }
240 | 


--------------------------------------------------------------------------------
/linux.go:
--------------------------------------------------------------------------------
  1 | package thyme
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"os/exec"
  6 | 	"regexp"
  7 | 	"strconv"
  8 | 	"strings"
  9 | 	"time"
 10 | )
 11 | 
 12 | func init() {
 13 | 	RegisterTracker("linux", NewLinuxTracker)
 14 | }
 15 | 
 16 | // LinuxTracker tracks application usage on Linux via a few standard command-line utilities.
 17 | type LinuxTracker struct{}
 18 | 
 19 | var _ Tracker = (*LinuxTracker)(nil)
 20 | 
 21 | func NewLinuxTracker() Tracker {
 22 | 	return &LinuxTracker{}
 23 | }
 24 | 
 25 | func (t *LinuxTracker) Deps() string {
 26 | 	return `
 27 | Install the following command-line utilities via your package manager of choice:
 28 | * xdpyinfo
 29 | * xwininfo
 30 | * xdotool
 31 | * wmctrl
 32 | 
 33 | For example:
 34 | * Debian: apt-get install x11-utils xdotool wmctrl
 35 | 
 36 | Note: this command prints out this message regardless of whether the dependencies are already installed.
 37 | `
 38 | }
 39 | 
 40 | func (t *LinuxTracker) Snap() (*Snapshot, error) {
 41 | 	var viewWidth, viewHeight int
 42 | 	{
 43 | 		out, err := exec.Command("bash", "-c", "xdpyinfo | grep dimensions").Output()
 44 | 		if err != nil {
 45 | 			return nil, fmt.Errorf("xdpyinfo failed with error: %s. Try running `xdpyinfo | grep dimensions` to diagnose.", err)
 46 | 		}
 47 | 		matches := dimRx.FindStringSubmatch(string(out))
 48 | 		if len(matches) != 3 {
 49 | 			return nil, fmt.Errorf("could not parse viewport dimensions from output line %q", string(out))
 50 | 		}
 51 | 		w, err := strconv.Atoi(matches[1])
 52 | 		if err != nil {
 53 | 			return nil, err
 54 | 		}
 55 | 		h, err := strconv.Atoi(matches[2])
 56 | 		if err != nil {
 57 | 			return nil, err
 58 | 		}
 59 | 		viewWidth, viewHeight = w, h
 60 | 	}
 61 | 
 62 | 	var windows []*Window
 63 | 	{
 64 | 		out, err := exec.Command("wmctrl", "-l").Output()
 65 | 		if err != nil {
 66 | 			return nil, fmt.Errorf("wmctrl failed with error: %s. Try running `wmctrl -l` to diagnose.", err)
 67 | 		}
 68 | 		lines := strings.Split(string(out), "\n")
 69 | 		for _, line := range lines {
 70 | 			fields := strings.Fields(line)
 71 | 			if len(fields) < 4 {
 72 | 				continue
 73 | 			}
 74 | 			id_, desktop_, name := fields[0], fields[1], strings.Join(fields[3:], " ")
 75 | 			id, err := strconv.ParseInt(id_, 0, 64)
 76 | 			if err != nil {
 77 | 				return nil, err
 78 | 			}
 79 | 			desktop, err := strconv.ParseInt(desktop_, 0, 64)
 80 | 			if err != nil {
 81 | 				return nil, err
 82 | 			}
 83 | 			w := Window{ID: id, Desktop: desktop, Name: name}
 84 | 			if !w.IsSystem() {
 85 | 				windows = append(windows, &w)
 86 | 			}
 87 | 		}
 88 | 	}
 89 | 
 90 | 	var currentDesktop int64
 91 | 	{
 92 | 		out, err := exec.Command("wmctrl", "-d").Output()
 93 | 		if err != nil {
 94 | 			return nil, err
 95 | 		}
 96 | 		lines := strings.Split(string(out), "\n")
 97 | 		for _, line := range lines {
 98 | 			fields := strings.Fields(line)
 99 | 			if len(fields) < 2 {
100 | 				continue
101 | 			}
102 | 			id_, mode := fields[0], fields[1]
103 | 			id, err := strconv.ParseInt(id_, 0, 64)
104 | 			if err != nil {
105 | 				return nil, err
106 | 			}
107 | 			if "*" == mode {
108 | 				currentDesktop = id
109 | 			}
110 | 		}
111 | 	}
112 | 
113 | 	var visible []int64
114 | 	{
115 | 		for _, window := range windows {
116 | 			out_, err := exec.Command("xwininfo", "-id", fmt.Sprintf("%d", window.ID), "-stats").Output()
117 | 			if err != nil {
118 | 				return nil, fmt.Errorf("xwininfo failed with error: %s", err)
119 | 			}
120 | 			out := string(out_)
121 | 			x, err := parseWinDim(xRx, out, "X")
122 | 			if err != nil {
123 | 				return nil, err
124 | 			}
125 | 			y, err := parseWinDim(yRx, out, "Y")
126 | 			if err != nil {
127 | 				return nil, err
128 | 			}
129 | 			w, err := parseWinDim(wRx, out, "W")
130 | 			if err != nil {
131 | 				return nil, err
132 | 			}
133 | 			h, err := parseWinDim(hRx, out, "H")
134 | 			if err != nil {
135 | 				return nil, err
136 | 			}
137 | 			if window.IsOnDesktop(currentDesktop) && isVisible(x, y, w, h, viewHeight, viewWidth) {
138 | 				visible = append(visible, window.ID)
139 | 			}
140 | 		}
141 | 	}
142 | 
143 | 	var active int64
144 | 	{
145 | 		out, err := exec.Command("xdotool", "getactivewindow").Output()
146 | 		if err != nil {
147 | 			return nil, fmt.Errorf("xdotool failed with error: %s. Try running `xdotool getactivewindow` to diagnose.", err)
148 | 		}
149 | 		id, err := strconv.ParseInt(strings.TrimSpace(string(out)), 10, 64)
150 | 		if err != nil {
151 | 			return nil, err
152 | 		}
153 | 		active = id
154 | 	}
155 | 
156 | 	return &Snapshot{Windows: windows, Active: active, Visible: visible, Time: time.Now()}, nil
157 | }
158 | 
159 | // isVisible checks if the window is visible in the current viewport.
160 | // x and y are assumed to be relative to the current viewport (i.e.,
161 | // (0, 0) is the coordinate of the top-left corner of the current
162 | // viewport.
163 | func isVisible(x, y, w, h, viewHeight, viewWidth int) bool {
164 | 	return (0 <= x && x < viewWidth && 0 <= y && y < viewHeight) ||
165 | 		(0 <= x+w && x+w < viewWidth && 0 <= y && y < viewHeight) ||
166 | 		(0 <= x && x < viewWidth && 0 <= y+h && y+h < viewHeight) ||
167 | 		(0 <= x+w && x+w < viewWidth && 0 <= y+h && y+h < viewHeight)
168 | }
169 | 
170 | var (
171 | 	dimRx = regexp.MustCompile(`dimensions:\s+([0-9]+)x([0-9]+)\s+pixels`)
172 | 	xRx   = regexp.MustCompile(`Absolute upper\-left X:\s+(\-?[0-9]+)`)
173 | 	yRx   = regexp.MustCompile(`Absolute upper\-left Y:\s+(\-?[0-9]+)`)
174 | 	wRx   = regexp.MustCompile(`Width:\s+([0-9]+)`)
175 | 	hRx   = regexp.MustCompile(`Height:\s+([0-9]+)`)
176 | )
177 | 
178 | // parseWinDim parses window dimension info from the output of `xwininfo`
179 | func parseWinDim(rx *regexp.Regexp, out string, varname string) (int, error) {
180 | 	if matches := rx.FindStringSubmatch(out); len(matches) == 2 {
181 | 		n, err := strconv.Atoi(matches[1])
182 | 		if err != nil {
183 | 			return 0, err
184 | 		}
185 | 		return n, nil
186 | 	} else {
187 | 		return 0, fmt.Errorf("could not parse window %s from output %s", varname, out)
188 | 	}
189 | 
190 | }
191 | 


--------------------------------------------------------------------------------
/list.go:
--------------------------------------------------------------------------------
1 | package thyme
2 | 
3 | import "fmt"
4 | 
5 | func List(stream *Stream) {
6 | 	fmt.Printf("%s", stream.Print())
7 | }
8 | 


--------------------------------------------------------------------------------
/release.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | for os in darwin windows linux; do
4 |     for arch in 386; do
5 |         env GOOS="$os" GOARCH="$arch" go build -o "./.bin/thyme-$os-$arch" ./cmd/thyme
6 |     done
7 | done
8 | 


--------------------------------------------------------------------------------
/show.go:
--------------------------------------------------------------------------------
  1 | package thyme
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"os"
  6 | 	"sort"
  7 | 	"strconv"
  8 | 	"text/template"
  9 | 	"time"
 10 | )
 11 | 
 12 | const maxNumberOfBars = 30
 13 | 
 14 | // Stats renders an HTML page with charts using stream as its data
 15 | // source. Currently, it renders the following charts:
 16 | // 1. A timeline of applications active, visible, and open
 17 | // 2. A timeline of windows active, visible, and open
 18 | // 3. A barchart of applications most often active, visible, and open
 19 | func Stats(stream *Stream) error {
 20 | 	tlFine := NewTimeline(stream, func(w *Window) string { return w.Name })
 21 | 	tlCoarse := NewTimeline(stream, appID)
 22 | 	agg := NewAggTime(stream, appID)
 23 | 
 24 | 	if err := statsTmpl.Execute(os.Stdout, &statsPage{
 25 | 		Fine:   tlFine,
 26 | 		Coarse: tlCoarse,
 27 | 		Agg:    agg,
 28 | 	}); err != nil {
 29 | 		return err
 30 | 	}
 31 | 	return nil
 32 | }
 33 | 
 34 | // AggTime is the list of bar charts that convey aggregate application time usage.
 35 | type AggTime struct {
 36 | 	Charts []*BarChart
 37 | }
 38 | 
 39 | // NewAggTime returns a new AggTime created from a Stream.
 40 | func NewAggTime(stream *Stream, labelFunc func(*Window) string) *AggTime {
 41 | 	n := strconv.Itoa(maxNumberOfBars)
 42 | 	active := NewBarChart("Active", "App", "Samples", "Top "+n+" active applications by time (multiplied by window count)")
 43 | 	visible := NewBarChart("Visible", "App", "Samples", "Top "+n+" visible applications by time (multiplied by window count)")
 44 | 	all := NewBarChart("All", "App", "Samples", "Top "+n+" open applications by time (multiplied by window count)")
 45 | 	for _, snap := range stream.Snapshots {
 46 | 		windows := make(map[int64]*Window)
 47 | 		for _, win := range snap.Windows {
 48 | 			windows[win.ID] = win
 49 | 		}
 50 | 
 51 | 		if win := windows[snap.Active]; win != nil {
 52 | 			active.Plus(labelFunc(windows[snap.Active]), 1)
 53 | 		}
 54 | 		for _, v := range snap.Visible {
 55 | 			visible.Plus(labelFunc(windows[v]), 1)
 56 | 		}
 57 | 		for _, win := range snap.Windows {
 58 | 			all.Plus(labelFunc(win), 1)
 59 | 		}
 60 | 	}
 61 | 	return &AggTime{Charts: []*BarChart{active, visible, all}}
 62 | }
 63 | 
 64 | // BarChart is a representation of a bar chart.
 65 | type BarChart struct {
 66 | 	ID     string
 67 | 	YLabel string
 68 | 	XLabel string
 69 | 	Title  string
 70 | 	Series map[string]int
 71 | }
 72 | 
 73 | // Bar represents a single bar in a bar chart.
 74 | type Bar struct {
 75 | 	Label string
 76 | 	Count int
 77 | }
 78 | 
 79 | // NewBarChart returns a new BarChart with the specified ID, x- and
 80 | // y-axis label, and title.
 81 | func NewBarChart(id, x, y, title string) *BarChart {
 82 | 	return &BarChart{ID: id, XLabel: x, YLabel: y, Title: title, Series: make(map[string]int)}
 83 | }
 84 | 
 85 | // Plus adds n to the count associated with the label.
 86 | func (c *BarChart) Plus(label string, n int) {
 87 | 	c.Series[label] += n
 88 | }
 89 | 
 90 | // OrderedBars returns a list of the top $maxNumberOfBars bars in the bar chart ordered by
 91 | // decreasing count.
 92 | func (c *BarChart) OrderedBars() []Bar {
 93 | 	var bars []Bar
 94 | 	for l, c := range c.Series {
 95 | 		bars = append(bars, Bar{Label: l, Count: c})
 96 | 	}
 97 | 	s := sortBars{bars}
 98 | 	sort.Sort(s)
 99 | 	numberOfBars := maxNumberOfBars
100 | 	if numberOfBars > len(s.bars) {
101 | 		numberOfBars = len(s.bars)
102 | 	}
103 | 	return s.bars[:numberOfBars]
104 | }
105 | 
106 | type sortBars struct {
107 | 	bars []Bar
108 | }
109 | 
110 | func (s sortBars) Len() int           { return len(s.bars) }
111 | func (s sortBars) Less(a, b int) bool { return s.bars[a].Count > s.bars[b].Count }
112 | func (s sortBars) Swap(a, b int)      { s.bars[a], s.bars[b] = s.bars[b], s.bars[a] }
113 | 
114 | // Timeline represents a timeline of application usage.
115 | // Start is the start time of the timeline.
116 | // End is the end time of the timeline.
117 | // Rows is a map where the keys are tags and the values are lists of
118 | // time ranges. Each row is a distinct sub-timeline.
119 | type Timeline struct {
120 | 	Start time.Time
121 | 	End   time.Time
122 | 	Rows  map[string][]*Range
123 | }
124 | 
125 | // Range represents a labeled range of time.
126 | type Range struct {
127 | 	Label string
128 | 	Start time.Time
129 | 	End   time.Time
130 | }
131 | 
132 | // NewTimeline returns a new Timeline created from the specified
133 | // Stream. labelFunc is used to determine the ID string to be used for
134 | // a given Window. If you're tracking events by app, this ID should
135 | // reflect the identity of the window's application. If you're
136 | // tracking events by window name, the ID should be the window name.
137 | func NewTimeline(stream *Stream, labelFunc func(*Window) string) *Timeline {
138 | 	if len(stream.Snapshots) == 0 {
139 | 		return nil
140 | 	}
141 | 	var active, visible, other []*Range
142 | 	var lastActive *Range
143 | 	var lastVisible, lastOther = make(map[string]*Range), make(map[string]*Range)
144 | 	for _, snap := range stream.Snapshots {
145 | 		windows := make(map[int64]*Window)
146 | 		for _, win := range snap.Windows {
147 | 			windows[win.ID] = win
148 | 		}
149 | 
150 | 		{
151 | 			if win := windows[snap.Active]; win != nil {
152 | 				winLabel := labelFunc(win)
153 | 				if lastActive != nil && lastActive.Label == winLabel {
154 | 					lastActive.End = snap.Time
155 | 				} else {
156 | 					if lastActive != nil {
157 | 						lastActive.End = snap.Time
158 | 					}
159 | 					newRange := &Range{Label: winLabel, Start: snap.Time, End: snap.Time}
160 | 					active = append(active, newRange)
161 | 					lastActive = newRange
162 | 				}
163 | 			} else {
164 | 				lastActive = nil
165 | 			}
166 | 		}
167 | 
168 | 		for _, prevRange := range lastVisible {
169 | 			prevRange.End = snap.Time
170 | 		}
171 | 		nextVisible := make(map[string]*Range)
172 | 		for _, v := range snap.Visible {
173 | 			var winLabel string
174 | 			if win := windows[v]; win != nil {
175 | 				winLabel = labelFunc(win)
176 | 			}
177 | 			if existRng, exists := lastVisible[winLabel]; !exists {
178 | 				newRange := &Range{Label: winLabel, Start: snap.Time, End: snap.Time}
179 | 				nextVisible[winLabel] = newRange
180 | 				visible = append(visible, newRange)
181 | 			} else {
182 | 				nextVisible[winLabel] = existRng
183 | 			}
184 | 		}
185 | 		lastVisible = nextVisible
186 | 
187 | 		for _, prevRange := range lastOther {
188 | 			prevRange.End = snap.Time
189 | 		}
190 | 		nextOther := make(map[string]*Range)
191 | 		for _, win := range snap.Windows {
192 | 			winLabel := labelFunc(win)
193 | 			if existRng, exists := lastOther[winLabel]; !exists {
194 | 				newRange := &Range{Label: winLabel, Start: snap.Time, End: snap.Time}
195 | 				nextOther[winLabel] = newRange
196 | 				other = append(other, newRange)
197 | 			} else {
198 | 				nextOther[winLabel] = existRng
199 | 			}
200 | 		}
201 | 		lastOther = nextOther
202 | 	}
203 | 	return &Timeline{
204 | 		Start: stream.Snapshots[0].Time,
205 | 		End:   stream.Snapshots[len(stream.Snapshots)-1].Time,
206 | 		Rows:  map[string][]*Range{"Active": active, "Visible": visible, "All": other},
207 | 	}
208 | }
209 | 
210 | // timeToJS is a template helper function that converts a time.Time to
211 | // code that creates a JavaScript Date object.
212 | func timeToJS(t time.Time) string {
213 | 	return fmt.Sprintf(`new Date(%d, %d, %d, %d, %d, %d)`, t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
214 | }
215 | 
216 | // statsPage is the data rendered in statsTmpl.
217 | type statsPage struct {
218 | 	Fine   *Timeline
219 | 	Coarse *Timeline
220 | 	Agg    *AggTime
221 | }
222 | 
223 | // statsTmpl is the HTML template for the page rendered by the `Stats`
224 | // function.
225 | var statsTmpl = template.Must(template.New("").Funcs(map[string]interface{}{
226 | 	"timeToJS": timeToJS,
227 | }).Parse(`<html>
228 |   <head>
229 | 	<meta charset="utf-8">
230 | 	<style>
231 | 		.description {
232 | 			font-family: Roboto;
233 | 			font-size: 16px;
234 | 			padding: 16px 0;
235 | 			color: rgb(117, 117, 117);
236 | 		}
237 | 	</style>
238 | 
239 |     <script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>
240 |     <script type="text/javascript">
241 |       google.charts.load('current', {'packages':['corechart', 'bar', 'timeline']});
242 | 	</script>
243 | 
244 | 	{{with .Coarse}}
245 |     <script type="text/javascript">
246 |       google.charts.setOnLoadCallback(drawChartCoarse);
247 |       function drawChartCoarse() {
248 |         var container = document.getElementById('timeline_coarse');
249 |         var chart = new google.visualization.Timeline(container);
250 |         var dataTable = new google.visualization.DataTable();
251 | 
252 |         dataTable.addColumn({ type: 'string', id: 'Status' });
253 | 		dataTable.addColumn({ type: 'string', id: 'Name' });
254 |         dataTable.addColumn({ type: 'date', id: 'Start' });
255 |         dataTable.addColumn({ type: 'date', id: 'End' });
256 |         dataTable.addRows([
257 | 		{{range .Rows.Active}}
258 | 			[
259 | 				"Active",
260 | 				{{printf "%q" .Label}},
261 | 				{{timeToJS .Start}},
262 | 				{{timeToJS .End}},
263 | 			],
264 | 		{{end}}
265 | 		{{range .Rows.Visible}}
266 | 			[
267 | 				"Visible",
268 | 				{{printf "%q" .Label}},
269 | 				{{timeToJS .Start}},
270 | 				{{timeToJS .End}},
271 | 			],
272 | 		{{end}}
273 | 		{{range .Rows.All}}
274 | 			[
275 | 				"All",
276 | 				{{printf "%q" .Label}},
277 | 				{{timeToJS .Start}},
278 | 				{{timeToJS .End}},
279 | 			],
280 | 		{{end}}
281 | 		]);
282 | 
283 | 		var options = {
284 | 			timeline: { showRowLabels: true },
285 | 		};
286 |         chart.draw(dataTable, options);
287 |       }
288 |     </script>
289 | 	{{end}}
290 | 
291 | 	{{range $chart := .Agg.Charts}}
292 | 	<script type="text/javascript">
293 | 	google.charts.setOnLoadCallback(drawBarChart{{$chart.ID}});
294 | 	function drawBarChart{{$chart.ID}}() {
295 |       var data = google.visualization.arrayToDataTable([
296 |         ['Application', 'Number of samples'],
297 | 		{{range $chart.OrderedBars}}
298 | 		[{{printf "%q" .Label}}, {{.Count}}],
299 | 		{{end}}
300 |       ]);
301 | 
302 |       var options = {
303 |         chart: {
304 |           title: '{{$chart.Title}}'
305 |         },
306 | 		legend: { position: "none" },
307 |         hAxis: {
308 |           title: '{{$chart.YLabel}}',
309 |           minValue: 0,
310 |         },
311 |         vAxis: {
312 |           title: '{{$chart.XLabel}}'
313 |         },
314 |         bars: 'horizontal',
315 |         height: 600
316 |       };
317 |       var material = new google.charts.Bar(document.getElementById('bar_chart_{{$chart.ID}}'));
318 |       material.draw(data, options);
319 |     }
320 | 	</script>
321 | 	{{end}}
322 | 
323 | 	{{with .Fine}}
324 |     <script type="text/javascript">
325 |       google.charts.setOnLoadCallback(drawChartFine);
326 |       function drawChartFine() {
327 |         var container = document.getElementById('timeline_fine');
328 |         var chart = new google.visualization.Timeline(container);
329 |         var dataTable = new google.visualization.DataTable();
330 | 
331 |         dataTable.addColumn({ type: 'string', id: 'Status' });
332 | 		dataTable.addColumn({ type: 'string', id: 'Name' });
333 |         dataTable.addColumn({ type: 'date', id: 'Start' });
334 |         dataTable.addColumn({ type: 'date', id: 'End' });
335 |         dataTable.addRows([
336 | 		{{range .Rows.Active}}
337 | 			[
338 | 				"Active",
339 | 				{{printf "%q" .Label}},
340 | 				{{timeToJS .Start}},
341 | 				{{timeToJS .End}},
342 | 			],
343 | 		{{end}}
344 | 		{{range .Rows.Visible}}
345 | 			[
346 | 				"Visible",
347 | 				{{printf "%q" .Label}},
348 | 				{{timeToJS .Start}},
349 | 				{{timeToJS .End}},
350 | 			],
351 | 		{{end}}
352 | 		{{range .Rows.All}}
353 | 			[
354 | 				"All",
355 | 				{{printf "%q" .Label}},
356 | 				{{timeToJS .Start}},
357 | 				{{timeToJS .End}},
358 | 			],
359 | 		{{end}}
360 | 		]);
361 | 
362 | 		var options = {
363 | 			timeline: { showRowLabels: true },
364 | 		};
365 |         chart.draw(dataTable, options);
366 |       }
367 |     </script>
368 | 	{{end}}
369 | 
370 | 
371 |   </head>
372 |   <body>
373 | 
374 | 	<div class="description">
375 | 		This is a coarse-grained timeline of all the applications you use over the course of the day. Every bar represents an application.
376 | 	</div>
377 |     <div id="timeline_coarse" style="min-height: 500px;"></div>
378 | 	<hr>
379 | 
380 | 	<div class="description">
381 | 		This is a fine-grained timeline of all the applications you use over the course of the day. Every bar represents a distinct window.
382 | 	</div>
383 |     <div id="timeline_fine" style="min-height: 500px;"></div>
384 | 	<hr>
385 | 
386 | 	{{range $chart := .Agg.Charts}}
387 | 	<div id="bar_chart_{{$chart.ID}}"></div>
388 | 	<hr>
389 | 	{{end}}
390 | 
391 |   </body>
392 | </html>`))
393 | 
394 | // appID returns a string that identifies the application of the
395 | // window, w. It does so in best effort fashion. If the application
396 | // can't be determined, it returns the the name of the window.
397 | func appID(w *Window) string {
398 | 	if w == nil {
399 | 		return "(nil)"
400 | 	}
401 | 	if w.Info().App != "" {
402 | 		return w.Info().App
403 | 	}
404 | 	if w.Info().SubApp != "" {
405 | 		return fmt.Sprintf("%s :: %s", w.Info().App, w.Info().SubApp)
406 | 	}
407 | 	if w.Info().Title != "" {
408 | 		return w.Info().Title
409 | 	}
410 | 	return w.Name
411 | }
412 | 


--------------------------------------------------------------------------------
/windows.go:
--------------------------------------------------------------------------------
  1 | // +build windows
  2 | 
  3 | package thyme
  4 | 
  5 | import (
  6 | 	"fmt"
  7 | 	"syscall"
  8 | 	"time"
  9 | 	"unsafe"
 10 | )
 11 | 
 12 | func init() {
 13 | 	RegisterTracker("windows", NewWindowsTracker)
 14 | }
 15 | 
 16 | // WindowsTracker tracks application usage using the "EnumWindows" win32 API. Windows is very liberal
 17 | // in what it calls a Window, so one Window (or application) may return multiple times with the same
 18 | // process ID, but different window titles. Which title is used is a matter of chance.
 19 | type WindowsTracker struct{}
 20 | 
 21 | var _ Tracker = (*WindowsTracker)(nil)
 22 | 
 23 | func NewWindowsTracker() Tracker {
 24 | 	return &WindowsTracker{}
 25 | }
 26 | 
 27 | var windowsIgnoreList []string = []string{
 28 | 	"Default IME",
 29 | 	"MSCTFIME UI",
 30 | }
 31 | 
 32 | var (
 33 | 	user                         = syscall.NewLazyDLL("user32.dll")
 34 | 	procGetForegroundWindow      = user.NewProc("GetForegroundWindow")
 35 | 	procGetWindowText            = user.NewProc("GetWindowTextW")
 36 | 	procGetWindowTextLengthW     = user.NewProc("GetWindowTextLengthW")
 37 | 	procEnumWindows              = user.NewProc("EnumWindows")
 38 | 	procIsWindow                 = user.NewProc("IsWindow")
 39 | 	procIsWindowVisible          = user.NewProc("IsWindowVisible")
 40 | 	procGetWindowThreadProcessId = user.NewProc("GetWindowThreadProcessId")
 41 | )
 42 | 
 43 | func (t *WindowsTracker) Deps() string {
 44 | 	return "Nothing, Ready to Go!"
 45 | }
 46 | 
 47 | // getWindowTitle returns a title of a window of the provided system window handle
 48 | func getWindowTitle(window uintptr) string {
 49 | 	textLength, _, _ := procGetWindowTextLengthW.Call(uintptr(window))
 50 | 	textLength += 1
 51 | 	titleBuffer := make([]uint16, textLength)
 52 | 	procGetWindowText.Call(uintptr(window), uintptr(unsafe.Pointer(&titleBuffer[0])), textLength)
 53 | 	return syscall.UTF16ToString(titleBuffer)
 54 | }
 55 | 
 56 | // getWindowID returns the process (thread) id that created the window. Multiple windows can share
 57 | // the same process id.
 58 | func getWindowID(window uintptr) int64 {
 59 | 	id, _, _ := procGetWindowThreadProcessId.Call(window, 0)
 60 | 	return int64(id)
 61 | }
 62 | 
 63 | // windowsIgnore will return true for titles of windows that are likely internal to windows itself
 64 | // and not the applications we care to monitor.
 65 | func windowsIgnore(title string) bool {
 66 | 	if title == "" {
 67 | 		return true
 68 | 	}
 69 | 	for _, ignore := range windowsIgnoreList {
 70 | 		if ignore == title {
 71 | 			return true
 72 | 		}
 73 | 	}
 74 | 	return false
 75 | }
 76 | 
 77 | func (t *WindowsTracker) Snap() (snap *Snapshot, err error) {
 78 | 	var allWindows []*Window
 79 | 	var visible []int64
 80 | 	var active int64
 81 | 
 82 | 	var cbId uintptr = 888
 83 | 
 84 | 	activeWindow, _, _ := procGetForegroundWindow.Call()
 85 | 	activeTitle := getWindowTitle(activeWindow)
 86 | 
 87 | 	cb := syscall.NewCallback(func(hwnd syscall.Handle, lparam uintptr) uintptr {
 88 | 		if lparam != cbId {
 89 | 			err = fmt.Errorf("lparam does not match what callback expected; received (%d), expected (%d)", lparam, cbId)
 90 | 			return 0
 91 | 		}
 92 | 		b, _, _ := procIsWindow.Call(uintptr(hwnd))
 93 | 		if b != 0 {
 94 | 			currentTitle := getWindowTitle(uintptr(hwnd))
 95 | 			currentId := getWindowID(uintptr(hwnd))
 96 | 			// Skip windows that are in a process where we already have a visible window
 97 | 			for _, visibleId := range visible {
 98 | 				if currentId == visibleId {
 99 | 					return 1
100 | 				}
101 | 			}
102 | 			if !windowsIgnore(currentTitle) {
103 | 				if activeTitle == currentTitle {
104 | 					active = currentId
105 | 				}
106 | 				v, _, _ := procIsWindowVisible.Call(uintptr(hwnd))
107 | 				if v != 0 {
108 | 					visible = append(visible, currentId)
109 | 				}
110 | 				allWindows = append(allWindows, &Window{ID: currentId, Name: currentTitle})
111 | 			}
112 | 		}
113 | 		return 1 // continue enumeration
114 | 	})
115 | 
116 | 	procEnumWindows.Call(cb, cbId)
117 | 
118 | 	return &Snapshot{
119 | 		Time:    time.Now(),
120 | 		Windows: allWindows,
121 | 		Active:  active,
122 | 		Visible: visible,
123 | 	}, err
124 | }
125 | 


--------------------------------------------------------------------------------