build/cmd/gopherstats/gopherstats.go

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"bytes"
	"context"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"github.com/google/go-github/github"
	"golang.org/x/build/gerrit"
	"golang.org/x/build/internal/gophers"
	"golang.org/x/build/maintner"
	"golang.org/x/build/maintner/godata"
	"golang.org/x/oauth2"
)

var (
	mode           = flag.String("mode", "", "mode to run in. Valid values:\n\n"+modeSummary())
	startTime      = newTimeFlag("from", "1900-01-01", "start of time range for the 'range-stats' mode")
	endTime        = newTimeFlag("to", "2100-01-01", "end of time range for the 'range-stats' mode")
	timeZone       = flag.String("tz", "US/Pacific", "timezone to use for time values")
	gerritProjects = newStringSetFlag("projects", "", "set of Gerrit projects to include; empty means all")
)

type stringSetFlag map[string]bool

func newStringSetFlag(name string, defVal string, desc string) *stringSetFlag {
	var s stringSetFlag
	s.Set(defVal)
	flag.Var(&s, name, desc)
	return &s
}

func (s *stringSetFlag) Includes(p string) bool {
	if len(*s) == 0 {
		return true
	}
	return (*s)[p]
}

func (s *stringSetFlag) Set(v string) error {
	if v == "" {
		*s = nil
		return nil
	}
	elms := strings.Split(v, ",")
	*s = make(map[string]bool, len(elms))
	for _, e := range elms {
		(*s)[e] = true
	}
	return nil
}

func (s *stringSetFlag) String() string {
	var elms []string
	for e := range *s {
		elms = append(elms, e)
	}
	sort.Strings(elms)
	return strings.Join(elms, ",")
}

func newTimeFlag(name, defVal, desc string) *time.Time {
	var t time.Time
	tf := (*timeFlag)(&t)
	if err := tf.Set(defVal); err != nil {
		panic(err.Error())
	}
	flag.Var(tf, name, desc)
	return &t
}

type timeFlag time.Time

func (t *timeFlag) String() string { return time.Time(*t).String() }
func (t *timeFlag) Set(v string) error {
	loc, err := time.LoadLocation(*timeZone)
	if err != nil {
		return err
	}
	for _, pat := range []string{
		time.RFC3339Nano,
		time.RFC3339,
		"2006-01-02T15:04:05",
		"2006-01-02T15:04",
		"2006-01-02",
	} {
		parsedTime, err := time.ParseInLocation(pat, v, loc)
		if err == nil {
			*t = timeFlag(parsedTime)
			return nil
		}
	}
	return fmt.Errorf("unrecognized RFC3339 or prefix %q", v)
}

type handler struct {
	fn   func(*statsClient)
	desc string
}

var modes = map[string]handler{
	"find-github-email":   {(*statsClient).findGithubEmails, "discover mappings between github usernames and emails"},
	"gerrit-groups":       {(*statsClient).gerritGroups, "print stats on gerrit groups"},
	"github-groups":       {(*statsClient).githubGroups, "print stats on github groups"},
	"github-issue-close":  {(*statsClient).githubIssueCloseStats, "print stats on github issues closes by quarter (googler-vs-not, unique numbers)"},
	"gerrit-cls":          {(*statsClient).gerritCLStats, "print stats on opened gerrit CLs by quarter"},
	"workshop-stats":      {(*statsClient).workshopStats, "print stats from contributor workshop"},
	"find-gerrit-gophers": {(*statsClient).findGerritGophers, "discover mappings between internal/gopher entries and Gerrit IDs"},
	"range-stats":         {(*statsClient).rangeStats, "show various summaries of activity in the flag-provided time range"},
}

func modeSummary() string {
	var buf bytes.Buffer
	var sorted []string
	for mode := range modes {
		sorted = append(sorted, mode)
	}
	sort.Strings(sorted)
	for _, mode := range sorted {
		fmt.Fprintf(&buf, "%q: %s\n", mode, modes[mode].desc)
	}
	return buf.String()
}

type statsClient struct {
	lazyGitHub *github.Client
	lazyGerrit *gerrit.Client

	corpusCache *maintner.Corpus
}

func (sc *statsClient) github() *github.Client {
	if sc.lazyGitHub != nil {
		return sc.lazyGitHub
	}
	ghc, err := getGithubClient()
	if err != nil {
		log.Fatal(err)
	}
	sc.lazyGitHub = ghc
	return ghc
}

func (sc *statsClient) gerrit() *gerrit.Client {
	if sc.lazyGerrit != nil {
		return sc.lazyGerrit
	}
	gerrc := gerrit.NewClient("https://go-review.googlesource.com", gerrit.GitCookieFileAuth(filepath.Join(os.Getenv("HOME"), ".gitcookies")))
	sc.lazyGerrit = gerrc
	return gerrc
}

func (sc *statsClient) corpus() *maintner.Corpus {
	if sc.corpusCache == nil {
		var err error
		sc.corpusCache, err = godata.Get(context.Background())
		if err != nil {
			log.Fatalf("Loading maintner corpus: %v", err)
		}
	}
	return sc.corpusCache
}

func main() {
	flag.Parse()

	if *mode == "" {
		fmt.Fprintf(os.Stderr, "Missing required --mode flag.\n")
		flag.Usage()
		os.Exit(1)
	}
	h, ok := modes[*mode]
	if !ok {
		fmt.Fprintf(os.Stderr, "Unknown --mode flag.\n")
		flag.Usage()
		os.Exit(1)
	}

	sc := &statsClient{}
	h.fn(sc)
}

func (sc *statsClient) gerritGroups() {
	ctx := context.Background()
	gerrc := sc.gerrit()

	groups, err := gerrc.GetGroups(ctx)
	if err != nil {
		log.Fatalf("Gerrit.GetGroups: %v", err)
	}
	for name, gi := range groups {
		switch name {
		case "admins", "approvers", "may-start-trybots", "gophers",
			"may-abandon-changes",
			"may-forge-author-identity", "osp-team",
			"release-managers":
			members, err := gerrc.GetGroupMembers(ctx, gi.ID)
			if err != nil {
				log.Fatal(err)
			}
			numGoog, numExt := 0, 0
			for _, member := range members {
				//fmt.Printf("  %s: %+v\n", name, member)
				p := gophers.GetGerritPerson(member)
				if p == nil {
					fmt.Printf("addPerson(%q, %q)\n", member.Name, member.Email)
				} else {
					if p.Googler {
						numGoog++
					} else {
						numExt++
					}
				}
			}
			fmt.Printf("Group %s: %d total (%d googlers, %d external)\n", name, numGoog+numExt, numGoog, numExt)
		}
	}
}

// quarter returns a quarter of a year, in the form "2017q1".
func quarter(t time.Time) string {
	// TODO: do this allocation-free? preculate them in init?
	return fmt.Sprintf("%04dq%v", t.Year(), (int(t.Month()-1)/3)+1)
}

func (sc *statsClient) githubIssueCloseStats() {
	repo := sc.corpus().GitHub().Repo("golang", "go")
	if repo == nil {
		log.Fatal("Failed to find Go repo.")
	}
	commClosed := map[string]map[*gophers.Person]int{}
	googClosed := map[string]map[*gophers.Person]int{}
	quarterSet := map[string]struct{}{}
	repo.ForeachIssue(func(gi *maintner.GitHubIssue) error {
		if !gi.Closed {
			return nil
		}
		gi.ForeachEvent(func(e *maintner.GitHubIssueEvent) error {
			if e.Type != "closed" {
				return nil
			}
			if e.Actor == nil {
				return nil
			}
			q := quarter(e.Created)
			quarterSet[q] = struct{}{}
			if commClosed[q] == nil {
				commClosed[q] = map[*gophers.Person]int{}
			}
			if googClosed[q] == nil {
				googClosed[q] = map[*gophers.Person]int{}
			}
			var p *gophers.Person
			if e.Actor.Login == "gopherbot" {
				gc := sc.corpus().GitCommit(e.CommitID)
				if gc != nil {
					email := gc.Author.Email()
					p = gophers.GetPerson(email)
					if p == nil {
						log.Printf("unknown closer email: %q", email)
					}
				}
			} else {
				p = gophers.GetPerson("@" + e.Actor.Login)
			}
			if p != nil {
				if p.Googler {
					googClosed[q][p]++
				} else {
					commClosed[q][p]++
				}
			}
			return nil
		})
		return nil
	})
	sumPeeps := func(m map[*gophers.Person]int) (sum int) {
		for _, v := range m {
			sum += v
		}
		return
	}
	var quarters []string
	for q := range quarterSet {
		quarters = append(quarters, q)
	}
	sort.Strings(quarters)
	for _, q := range quarters {
		googTotal := sumPeeps(googClosed[q])
		commTotal := sumPeeps(commClosed[q])
		googUniq := len(googClosed[q])
		commUniq := len(commClosed[q])
		tot := googTotal + commTotal
		totUniq := googUniq + commUniq
		percentGoog := 100 * float64(googTotal) / float64(tot)
		fmt.Printf("%s closed issues: %v closes (%.2f%% goog %d; ext %d), %d unique people (%d goog, %d ext)\n",
			q, tot,
			percentGoog, googTotal, commTotal,
			totUniq, googUniq, commUniq,
		)
	}
}

type personSet struct {
	s       map[*gophers.Person]struct{}
	numGoog int
	numExt  int
}

func (s *personSet) sum() int { return len(s.s) }

func (s *personSet) add(p *gophers.Person) {
	if s.s == nil {
		s.s = make(map[*gophers.Person]struct{})
	}
	if _, ok := s.s[p]; !ok {
		s.s[p] = struct{}{}
		if p.Googler {
			s.numGoog++
		} else {
			s.numExt++
		}
	}
}

func (sc *statsClient) githubGroups() {
	ctx := context.Background()
	ghc := sc.github()
	teamList, _, err := ghc.Repositories.ListTeams(ctx, "golang", "go", nil)
	if err != nil {
		log.Fatal(err)
	}

	var teams = map[string]*personSet{}
	for _, t := range teamList {
		teamName := t.GetName()
		switch teamName {
		default:
			continue
		case "go-approvers", "gophers":
		}

		ps := new(personSet)
		teams[teamName] = ps
		users, _, err := ghc.Teams.ListTeamMembers(ctx, t.GetID(), &github.TeamListTeamMembersOptions{
			ListOptions: github.ListOptions{PerPage: 1000},
		})
		if err != nil {
			log.Fatal(err)
		}

		for _, u := range users {
			login := strings.ToLower(u.GetLogin())
			if login == "gopherbot" {
				continue
			}
			p := gophers.GetPerson("@" + login)
			if p == nil {
				panic(fmt.Sprintf("failed to find github person %q", "@"+login))
			}
			ps.add(p)
		}
	}

	cur := teams["go-approvers"]
	prev := parseOldSnapshot(githubGoApprovers20170106)
	log.Printf("Approvers 2016-12-13: %d: %v goog, %v ext", prev.sum(), prev.numGoog, prev.numExt)
	log.Printf("Approvers        cur: %d: %v goog, %v ext", cur.sum(), cur.numGoog, cur.numExt)
}

func parseOldSnapshot(s string) *personSet {
	ps := new(personSet)
	for _, f := range strings.Fields(s) {
		if !strings.HasPrefix(f, "@") {
			continue
		}
		p := gophers.GetPerson(f)
		if p == nil {
			panic(fmt.Sprintf("failed to find github person %q", f))
		}
		ps.add(p)
	}
	return ps
}

// Gerrit 2016-12-13:
// May start trybots, non-Googlers: 11
// Approvers, non-Googlers: 19

const githubGoApprovers20170106 = `
@0intro
0intro
David du Colombier

@4ad
4ad
Aram Hăvărneanu

@adams-sarah
adams-sarah
Sarah Adams

@adg
adg Owner
Andrew Gerrand

@alexbrainman
alexbrainman
Alex Brainman

@ality
ality
Anthony Martin

@campoy
campoy
Francesc Campoy

@DanielMorsing
DanielMorsing
Daniel Morsing

@davecheney
davecheney
Dave Cheney

@davidlazar
davidlazar
David Lazar

@dvyukov
dvyukov
Dmitry Vyukov

@eliasnaur
eliasnaur
Elias Naur

@hanwen
hanwen
Han-Wen Nienhuys

@josharian
josharian
Josh Bleecher Snyder

@jpoirier
jpoirier
Joseph Poirier

@kardianos
kardianos
Daniel Theophanes

@martisch
martisch
Martin Möhrmann

@matloob
matloob
Michael Matloob

@mdempsky
mdempsky
Matthew Dempsky

@mikioh
mikioh
Mikio Hara

@minux
minux
Minux Ma

@mwhudson
mwhudson
Michael Hudson-Doyle

@neild
neild
Damien Neil

@niemeyer
niemeyer
Gustavo Niemeyer

@odeke-em
odeke-em
Emmanuel T Odeke

@quentinmit
quentinmit Owner
Quentin Smith

@rakyll
rakyll
jbd@

@remyoudompheng
remyoudompheng
Rémy Oudompheng

@rminnich
rminnich
ron minnich

@rogpeppe
rogpeppe
Roger Peppe

@rui314
rui314
Rui Ueyama

@thanm
thanm
Than McIntosh
`

const githubGoAssignees20170106 = `
@crawshaw
crawshaw Team maintainer
David Crawshaw

@0intro
0intro
David du Colombier

@4ad
4ad
Aram Hăvărneanu

@adams-sarah
adams-sarah
Sarah Adams

@alexbrainman
alexbrainman
Alex Brainman

@alexcesaro
alexcesaro
Alexandre Cesaro

@ality
ality
Anthony Martin

@artyom
artyom
Artyom Pervukhin

@bcmills
bcmills
Bryan C. Mills

@billotosyr
billotosyr

@brtzsnr
brtzsnr
Alexandru Moșoi

@bsiegert
bsiegert
Benny Siegert

@c4milo
c4milo
Camilo Aguilar

@carl-mastrangelo
carl-mastrangelo
Carl Mastrangelo

@cespare
cespare
Caleb Spare

@DanielMorsing
DanielMorsing
Daniel Morsing

@davecheney
davecheney
Dave Cheney

@dominikh
dominikh
Dominik Honnef

@dskinner
dskinner
Daniel Skinner

@dsnet
dsnet
Joe Tsai

@dspezia
dspezia
Didier Spezia

@eliasnaur
eliasnaur
Elias Naur

@emergencybutter
emergencybutter
Arnaud

@evandbrown
evandbrown
Evan Brown

@fatih
fatih
Fatih Arslan

@garyburd
garyburd
Gary Burd

@hanwen
hanwen
Han-Wen Nienhuys

@jeffallen
jeffallen
Jeff R. Allen

@johanbrandhorst
johanbrandhorst
Johan Brandhorst

@josharian
josharian
Josh Bleecher Snyder

@jtsylve
jtsylve
Joe Sylve

@kardianos
kardianos
Daniel Theophanes

@kytrinyx
kytrinyx
Katrina Owen

@marete
marete
Brian Gitonga Marete

@martisch
martisch
Martin Möhrmann

@mattn
mattn
mattn

@mdempsky
mdempsky
Matthew Dempsky

@mdlayher
mdlayher
Matt Layher

@mikioh
mikioh
Mikio Hara

@millerresearch
millerresearch
Richard Miller

@minux
minux
Minux Ma

@mundaym
mundaym
Michael Munday

@mwhudson
mwhudson
Michael Hudson-Doyle

@myitcv
myitcv
Paul Jolly

@neelance
neelance
Richard Musiol

@niemeyer
niemeyer
Gustavo Niemeyer

@nodirt
nodirt
Nodir Turakulov

@rahulchaudhry
rahulchaudhry
Rahul Chaudhry

@rauls5382
rauls5382
Raul Silvera

@remyoudompheng
remyoudompheng
Rémy Oudompheng

@rhysh
rhysh
Rhys Hiltner

@rogpeppe
rogpeppe
Roger Peppe

@rsc
rsc Owner
Russ Cox

@rui314
rui314
Rui Ueyama

@sbinet
sbinet
Sebastien Binet

@shawnps
shawnps
Shawn Smith

@thanm
thanm
Than McIntosh

@titanous
titanous
Jonathan Rudenberg

@tombergan
tombergan

@tzneal
tzneal
Todd

@vstefanovic
vstefanovic

@wathiede
wathiede
Bill

@x1ddos
x1ddos
alex

@zombiezen
zombiezen
Ross Light
`

var discoverGoRepo = flag.String("discovery-go-repo", "go", "github.com/golang repo to discovery email addreses from")

func foreachProjectUnsorted(g *maintner.Gerrit, f func(gp *maintner.GerritProject) error) {
	g.ForeachProjectUnsorted(func(gp *maintner.GerritProject) error {
		if !gerritProjects.Includes(gp.Project()) {
			log.Printf("skipping project %s", gp.Project())
			return nil
		}
		return f(gp)
	})
}

func (sc *statsClient) findGerritGophers() {
	gerrc := sc.gerrit()
	log.Printf("find gerrit gophers")
	gerritEmails := map[string]int{}

	const suffix = "@62eb7196-b449-3ce5-99f1-c037f21e1705"

	foreachProjectUnsorted(sc.corpus().Gerrit(), func(gp *maintner.GerritProject) error {
		return gp.ForeachCLUnsorted(func(cl *maintner.GerritCL) error {
			for _, meta := range cl.Metas {
				who := meta.Commit.Author.Email()
				if strings.HasSuffix(who, suffix) {
					gerritEmails[who]++
				}
			}
			return nil
		})
	})

	var emails []string
	for k := range gerritEmails {
		emails = append(emails, k)
	}
	sort.Slice(emails, func(i, j int) bool {
		return gerritEmails[emails[j]] < gerritEmails[emails[i]]
	})
	for _, email := range emails {
		p := gophers.GetPerson(email)
		if p == nil {
			ai, err := gerrc.GetAccountInfo(context.Background(), strings.TrimSuffix(email, suffix))
			if err != nil {
				log.Printf("Looking up %s: %v", email, err)
				continue
			}
			fmt.Printf("addPerson(%q, %q, %q)\n", ai.Name, ai.Email, email)
		}
	}

}

func (sc *statsClient) findGithubEmails() {
	ghc := sc.github()
	seen := map[string]bool{}
	for page := 1; page < 500; page++ {
		commits, _, err := ghc.Repositories.ListCommits(context.Background(), "golang", *discoverGoRepo, &github.CommitsListOptions{
			ListOptions: github.ListOptions{Page: page, PerPage: 1000},
		})
		if err != nil {
			log.Fatalf("page %d: %v", page, err)
		}
		for _, com := range commits {
			ghUser := com.Author.GetLogin()
			if ghUser == "" {
				continue
			}
			if seen[ghUser] {
				continue
			}
			seen[ghUser] = true
			ca := com.Commit.Author

			p := gophers.GetPerson("@" + ghUser)
			if p != nil && gophers.GetPerson(ca.GetEmail()) == p {
				// Nothing new.
				continue
			}
			fmt.Printf("addPerson(%q, %q, %q)\n", ca.GetName(), ca.GetEmail(), "@"+ghUser)
		}
	}
}

func (sc *statsClient) gerritCLStats() {
	perQuarter := map[string]int{}
	perQuarterGoog := map[string]int{}
	perQuarterExt := map[string]int{}
	printedUnknown := map[string]bool{}
	perQuarterUniq := map[string]*personSet{}

	foreachProjectUnsorted(sc.corpus().Gerrit(), func(gp *maintner.GerritProject) error {
		gp.ForeachCLUnsorted(func(cl *maintner.GerritCL) error {
			q := quarter(cl.Created)
			perQuarter[q]++
			email := cl.Commit.Author.Email()
			p := gophers.GetPerson(email)
			var isGoog bool
			if p != nil {
				isGoog = p.Googler
				if _, ok := perQuarterUniq[q]; !ok {
					perQuarterUniq[q] = new(personSet)
				}
				perQuarterUniq[q].add(p)
			} else {
				isGoog = strings.HasSuffix(email, "@google.com")
				if !printedUnknown[email] {
					printedUnknown[email] = true
					fmt.Printf("addPerson(%q, %q)\n", cl.Commit.Author.Name(), email)

				}
			}
			if isGoog {
				perQuarterGoog[q]++
			} else {
				perQuarterExt[q]++
			}
			return nil
		})
		return nil
	})
	for _, q := range sortedStrMapKeys(perQuarter) {
		goog := perQuarterGoog[q]
		ext := perQuarterExt[q]
		tot := goog + ext
		fmt.Printf("%s: %d commits (%0.2f%% %d goog, %d ext)\n", q, perQuarter[q], 100*float64(goog)/float64(tot), goog, ext)
	}
	for _, q := range sortedStrMapKeys(perQuarter) {
		ps := perQuarterUniq[q]
		fmt.Printf("%s: %d unique users (%0.2f%% %d goog, %d ext)\n", q, len(ps.s), 100*float64(ps.numGoog)/float64(len(ps.s)), ps.numGoog, ps.numExt)
	}
}

func sortedStrMapKeys(m map[string]int) []string {
	ret := make([]string, 0, len(m))
	for k := range m {
		ret = append(ret, k)
	}
	sort.Strings(ret)
	return ret
}

func (sc *statsClient) workshopStats() {
	const workshopIssue = 21017
	loc, err := time.LoadLocation("America/Denver")
	if err != nil {
		fmt.Fprintf(os.Stderr, "loading location failed: %v", err)
		os.Exit(2)
	}
	workshopStartDate := time.Date(2017, time.July, 15, 0, 0, 0, 0, loc)

	// The key is the string representation of the gerrit ID.
	// The value is the string for the GitHub login.
	contributors := map[string]string{}

	// Get all the contributors from comments on the issue.
	sc.corpus().GitHub().Repo("golang", "go").Issue(workshopIssue).ForeachComment(func(c *maintner.GitHubComment) error {
		contributors[strings.TrimSpace(c.Body)] = c.User.Login
		return nil
	})
	fmt.Printf("Number of registrations: %d\n", len(contributors))

	// Store the already known contributors before the workshop.
	knownContributors := map[string]struct{}{}

	type projectStats struct {
		name      string
		openedCLs []string // Gerrit IDs of owners of opened CLs
		mergedCLs []string // Gerrit IDs of owners of merged CLs
	}
	ps := []projectStats{}

	// Get all the CLs during the time of the workshop and after.
	foreachProjectUnsorted(sc.corpus().Gerrit(), func(gp *maintner.GerritProject) error {
		p := projectStats{
			name: gp.Project(),
		}
		gp.ForeachCLUnsorted(func(cl *maintner.GerritCL) error {
			ownerID := fmt.Sprintf("%d", cl.OwnerID())
			// Make sure it was made after the workshop started
			// otherwise save as a known contributor.
			if cl.Created.After(workshopStartDate) {
				if _, ok := contributors[ownerID]; ok {
					p.openedCLs = append(p.openedCLs, ownerID)
					if cl.Status == "merged" {
						p.mergedCLs = append(p.mergedCLs, ownerID)
					}
				}
			} else {
				knownContributors[ownerID] = struct{}{}
			}
			return nil
		})

		// Return early if no one contributed to that project.
		if len(p.openedCLs) == 0 && len(p.mergedCLs) == 0 {
			return nil
		}

		ps = append(ps, p)
		return nil
	})

	sort.Slice(ps, func(i, j int) bool { return ps[i].name < ps[j].name })
	for _, p := range ps {
		var newOpened, newMerged int

		// Determine the first time contributors.
		for _, id := range p.openedCLs {
			if _, ok := knownContributors[id]; !ok {
				newOpened++
			}
		}
		for _, id := range p.mergedCLs {
			if _, ok := knownContributors[id]; !ok {
				newMerged++
			}
		}

		// Ignore repos where only past contributors had patches merged.
		if newOpened != 0 || newMerged != 0 {
			fmt.Printf(`%s:
	Total Opened CLs: %d
	Total Merged CLs: %d
	New Contributors Opened CLs: %d
	New Contributors Merged CLs: %d`+"\n", p.name, len(p.openedCLs), len(p.mergedCLs), newOpened, newMerged)
		}
	}
}

func (sc *statsClient) rangeStats() {
	var (
		newCLs                    = map[*gophers.Person]int{}
		commentsOnOtherCLs        = map[*gophers.Person]int{}
		githubIssuesCreated       = map[*gophers.Person]int{}
		githubUniqueIssueComments = map[*gophers.Person]int{} // non-owner
		githubUniqueIssueEvents   = map[*gophers.Person]int{} // non-owner
		uniqueFilesEdited         = map[*gophers.Person]int{}
		uniqueDirsEdited          = map[*gophers.Person]int{}
	)

	t1 := *startTime
	t2 := *endTime

	sc.corpus().GitHub().ForeachRepo(func(r *maintner.GitHubRepo) error {
		if r.ID().Owner != "golang" {
			return nil
		}
		return r.ForeachIssue(func(gi *maintner.GitHubIssue) error {
			if gi.User == nil {
				return nil
			}
			owner := gophers.GetPerson("@" + gi.User.Login)
			if gi.Created.After(t1) && gi.Created.Before(t2) {
				if owner == nil {
					log.Printf("No owner for golang.org/issue/%d (%q)", gi.Number, gi.User.Login)
				} else if !owner.Bot {
					githubIssuesCreated[owner]++
				}
			}

			sawCommenter := map[*gophers.Person]bool{}
			gi.ForeachComment(func(gc *maintner.GitHubComment) error {
				if gc.User == nil || gc.User.ID == gi.User.ID {
					return nil
				}
				if gc.Created.After(t1) && gc.Created.Before(t2) {
					commenter := gophers.GetPerson("@" + gc.User.Login)
					if commenter == nil || sawCommenter[commenter] || commenter.Bot {
						return nil
					}
					sawCommenter[commenter] = true
					githubUniqueIssueComments[commenter]++
				}
				return nil
			})

			sawEventer := map[*gophers.Person]bool{}
			gi.ForeachEvent(func(gc *maintner.GitHubIssueEvent) error {
				if gc.Actor == nil || gc.Actor.ID == gi.User.ID {
					return nil
				}
				if gc.Created.After(t1) && gc.Created.Before(t2) {
					eventer := gophers.GetPerson("@" + gc.Actor.Login)
					if eventer == nil || sawEventer[eventer] || eventer.Bot {
						return nil
					}
					sawEventer[eventer] = true
					githubUniqueIssueEvents[eventer]++
				}
				return nil
			})

			return nil
		})
	})

	type projectFile struct {
		gp   *maintner.GerritProject
		file string
	}
	var fileTouched = map[*gophers.Person]map[projectFile]bool{}
	var dirTouched = map[*gophers.Person]map[projectFile]bool{}

	foreachProjectUnsorted(sc.corpus().Gerrit(), func(gp *maintner.GerritProject) error {
		if gp.Server() != "go.googlesource.com" {
			return nil
		}
		return gp.ForeachCLUnsorted(func(cl *maintner.GerritCL) error {
			owner := gophers.GetPerson(cl.Commit.Author.Email())
			if cl.Created.After(t1) && cl.Created.Before(t2) {
				newCLs[owner]++
			}

			if ct := cl.Commit.CommitTime; ct.After(t1) && ct.Before(t2) && cl.Status == "merged" {
				email := cl.Commit.Author.Email() // gerrit-y email
				who := gophers.GetPerson(email)
				if who != nil {
					if len(cl.Commit.Files) > 20 {
						// Probably just a cleanup or moving files, skip this CL.
						return nil
					}
					if fileTouched[who] == nil {
						fileTouched[who] = map[projectFile]bool{}
					}
					if dirTouched[who] == nil {
						dirTouched[who] = map[projectFile]bool{}
					}
					for _, diff := range cl.Commit.Files {
						if strings.Contains(diff.File, "vendor/") {
							continue
						}
						fileTouched[who][projectFile{gp, diff.File}] = true
						dirTouched[who][projectFile{gp, path.Dir(diff.File)}] = true
					}
				}
			}

			saw := map[*gophers.Person]bool{}
			for _, meta := range cl.Metas {
				t := meta.Commit.CommitTime
				if t.Before(t1) || t.After(t2) {
					continue
				}
				email := meta.Commit.Author.Email() // gerrit-y email
				who := gophers.GetPerson(email)
				if who == owner || who == nil || saw[who] || who.Bot {
					continue
				}
				saw[who] = true
				commentsOnOtherCLs[who]++
			}
			return nil
		})
	})

	for p, m := range fileTouched {
		uniqueFilesEdited[p] = len(m)
	}
	for p, m := range dirTouched {
		uniqueDirsEdited[p] = len(m)
	}

	top(newCLs, "CLs created:", 40)
	top(commentsOnOtherCLs, "Unique non-self CLs commented on:", 40)

	top(githubIssuesCreated, "GitHub issues created:", 40)
	top(githubUniqueIssueComments, "Unique GitHub issues commented on:", 40)
	top(githubUniqueIssueEvents, "Unique GitHub issues acted on:", 40)

	top(uniqueFilesEdited, "Unique files edited:", 40)
	top(uniqueDirsEdited, "Unique directories edited:", 40)
}

func top(m map[*gophers.Person]int, title string, n int) {
	var kk []*gophers.Person
	for k := range m {
		if k == nil {
			continue
		}
		kk = append(kk, k)
	}
	sort.Slice(kk, func(i, j int) bool { return m[kk[j]] < m[kk[i]] })
	fmt.Println(title)
	for i, k := range kk {
		if i == n {
			break
		}
		fmt.Printf(" %5d %s\n", m[k], k.Name)
	}
	fmt.Println()
}

func getGithubToken() (string, error) {
	// TODO: get from GCE metadata, etc.
	tokenFile := filepath.Join(os.Getenv("HOME"), "keys", "github-read-org")
	slurp, err := ioutil.ReadFile(tokenFile)
	if err != nil {
		return "", err
	}
	f := strings.SplitN(strings.TrimSpace(string(slurp)), ":", 2)
	if len(f) != 2 || f[0] == "" || f[1] == "" {
		return "", fmt.Errorf("Expected token file %s to be of form <username>:<token>", tokenFile)
	}
	return f[1], nil
}

func getGithubClient() (*github.Client, error) {
	token, err := getGithubToken()
	if err != nil {
		return nil, err
	}
	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
	tc := oauth2.NewClient(context.Background(), ts)
	return github.NewClient(tc), nil
}