webtry: Switch from Go's log package to golang/glog.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
         "fmt"
         htemplate "html/template"
         "image"
         _ "image/gif"
         _ "image/jpeg"
         "image/png"
         "io/ioutil"
-        "log"
         "math/rand"
         "net"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
         "strings"
         "text/template"
         "time"
 )
 
 import (
         "github.com/fiorix/go-web/autogzip"
         _ "github.com/go-sql-driver/mysql"
+        "github.com/golang/glog"
         _ "github.com/mattn/go-sqlite3"
         "github.com/rcrowley/go-metrics"
 )
 
 const (
         DEFAULT_SAMPLE = `void draw(SkCanvas* canvas) {
     SkPaint p;
     p.setColor(SK_ColorRED);
     p.setAntiAlias(true);
     p.setStyle(SkPaint::kStroke_Style);
@@ skipping 91 matching lines @@
         return strings.Join(ret, "\n")
 }
 
 func init() {
         rand.Seed(time.Now().UnixNano())
 
         // Change the current working directory to the directory of the executable.
         var err error
         cwd, err := filepath.Abs(filepath.Dir(os.Args[0]))
         if err != nil {
-                log.Fatal(err)
+                glog.Fatal(err)
         }
         os.Chdir(cwd)
 
         codeTemplate = template.Must(template.ParseFiles(filepath.Join(cwd, "templates/template.cpp")))
         gypTemplate = template.Must(template.ParseFiles(filepath.Join(cwd, "templates/template.gyp")))
         indexTemplate = htemplate.Must(htemplate.ParseFiles(
                 filepath.Join(cwd, "templates/index.html"),
                 filepath.Join(cwd, "templates/titlebar.html"),
                 filepath.Join(cwd, "templates/sidebar.html"),
                 filepath.Join(cwd, "templates/content.html"),
@@ skipping 38 matching lines @@
         // See https://developers.google.com/compute/docs/metadata#custom.
         req, err := http.NewRequest("GET", "http://metadata/computeMetadata/v1/instance/attributes/password", nil)
         if err != nil {
                 panic(err)
         }
         client := http.Client{}
         req.Header.Add("X-Google-Metadata-Request", "True")
         if resp, err := client.Do(req); err == nil {
                 password, err := ioutil.ReadAll(resp.Body)
                 if err != nil {
-                        log.Printf("ERROR: Failed to read password from metadata server: %q\n", err)
+                        glog.Errorf("Failed to read password from metadata server: %q\n", err)
                         panic(err)
                 }
                 // The IP address of the database is found here:
                 //    https://console.developers.google.com/project/31977622648/sql/instances/webtry/overview
                 // And 3306 is the default port for MySQL.
                 db, err = sql.Open("mysql", fmt.Sprintf("webtry:%s@tcp(173.194.83.52:3306)/webtry?parseTime=true", password))
                 if err != nil {
-                        log.Printf("ERROR: Failed to open connection to SQL server: %q\n", err)
+                        glog.Errorf("ERROR: Failed to open connection to SQL server: %q\n", err)
                         panic(err)
                 }
         } else {
-                log.Printf("INFO: Failed to find metadata, unable to connect to MySQL server (Expected when running locally): %q\n", err)
+                glog.Infof("Failed to find metadata, unable to connect to MySQL server (Expected when running locally): %q\n", err)
                 // Fallback to sqlite for local use.
                 db, err = sql.Open("sqlite3", "./webtry.db")
                 if err != nil {
-                        log.Printf("ERROR: Failed to open: %q\n", err)
+                        glog.Errorf("Failed to open: %q\n", err)
                         panic(err)
                 }
                 sql := `CREATE TABLE IF NOT EXISTS source_images (
              id        INTEGER     PRIMARY KEY                NOT NULL,
              image     MEDIUMBLOB  DEFAULT ''                 NOT NULL, -- formatted as a PNG.
              width     INTEGER     DEFAULT 0                  NOT NULL,
              height    INTEGER     DEFAULT 0                  NOT NULL,
              create_ts TIMESTAMP   DEFAULT CURRENT_TIMESTAMP  NOT NULL,
              hidden    INTEGER     DEFAULT 0                  NOT NULL
              )`
                 _, err = db.Exec(sql)
                 if err != nil {
-                        log.Printf("Info: status creating sqlite table for sources: %q\n", err)
+                        glog.Infof("status creating sqlite table for sources: %q\n", err)
                 }
 
                 sql = `CREATE TABLE IF NOT EXISTS webtry (
              code               TEXT      DEFAULT ''                 NOT NULL,
              create_ts          TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
              hash               CHAR(64)  DEFAULT ''                 NOT NULL,
              width              INTEGER   DEFAULT 256                NOT NULL,
              height             INTEGER   DEFAULT 256                NOT NULL,
              gpu                BOOL      DEFAULT 0                  NOT NULL,
              source_image_id    INTEGER   DEFAULT 0                  NOT NULL,
 
              PRIMARY KEY(hash)
             )`
                 _, err = db.Exec(sql)
                 if err != nil {
-                        log.Printf("Info: status creating sqlite table for webtry: %q\n", err)
+                        glog.Infof("status creating sqlite table for webtry: %q\n", err)
                 }
 
                 sql = `CREATE TABLE IF NOT EXISTS workspace (
           name      CHAR(64)  DEFAULT ''                 NOT NULL,
           create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
           PRIMARY KEY(name)
         )`
                 _, err = db.Exec(sql)
                 if err != nil {
-                        log.Printf("Info: status creating sqlite table for workspace: %q\n", err)
+                        glog.Infof("status creating sqlite table for workspace: %q\n", err)
                 }
 
                 sql = `CREATE TABLE IF NOT EXISTS workspacetry (
           name               CHAR(64)  DEFAULT ''                 NOT NULL,
           create_ts          TIMESTAMP DEFAULT CURRENT_TIMESTAMP  NOT NULL,
           hash               CHAR(64)  DEFAULT ''                 NOT NULL,
           width              INTEGER   DEFAULT 256                NOT NULL,
           height             INTEGER   DEFAULT 256                NOT NULL,
           gpu                BOOL      DEFAULT 0                  NOT NULL,
           hidden             INTEGER   DEFAULT 0                  NOT NULL,
           source_image_id    INTEGER   DEFAULT 0                  NOT NULL,
 
           FOREIGN KEY (name)   REFERENCES workspace(name)
         )`
                 _, err = db.Exec(sql)
                 if err != nil {
-                        log.Printf("Info: status creating sqlite table for workspace try: %q\n", err)
+                        glog.Infof("status creating sqlite table for workspace try: %q\n", err)
                 }
         }
 
         // Ping the database to keep the connection fresh.
         go func() {
                 c := time.Tick(1 * time.Minute)
                 for _ = range c {
                         if err := db.Ping(); err != nil {
-                                log.Printf("ERROR: Database failed to respond: %q\n", err)
+                                glog.Errorf("Database failed to respond: %q\n", err)
                         }
                 }
         }()
 
         metrics.RegisterRuntimeMemStats(metrics.DefaultRegistry)
         go metrics.CaptureRuntimeMemStats(metrics.DefaultRegistry, 1*time.Minute)
 
         // Start reporting metrics.
         // TODO(jcgregorio) We need a centrialized config server for storing things
         // like the IP address of the Graphite monitor.
         addr, _ := net.ResolveTCPAddr("tcp", "skia-monitoring-b:2003")
         go metrics.Graphite(metrics.DefaultRegistry, 1*time.Minute, "webtry", addr)
 
         writeOutAllSourceImages()
 }
 
 func writeOutAllSourceImages() {
         // Pull all the source images from the db and write them out to inout.
         rows, err := db.Query("SELECT id, image, create_ts FROM source_images ORDER BY create_ts DESC")
 
         if err != nil {
-                log.Printf("ERROR: Failed to open connection to SQL server: %q\n", err)
+                glog.Errorf("Failed to open connection to SQL server: %q\n", err)
                 panic(err)
         }
         for rows.Next() {
                 var id int
                 var image []byte
                 var create_ts time.Time
                 if err := rows.Scan(&id, &image, &create_ts); err != nil {
-                        log.Printf("Error: failed to fetch from database: %q", err)
+                        glog.Errorf("failed to fetch from database: %q", err)
                         continue
                 }
                 filename := fmt.Sprintf("../../../inout/image-%d.png", id)
                 if _, err := os.Stat(filename); os.IsExist(err) {
-                        log.Printf("Skipping write since file exists: %q", filename)
+                        glog.Infof("Skipping write since file exists: %q", filename)
                         continue
                 }
                 if err := ioutil.WriteFile(filename, image, 0666); err != nil {
-                        log.Printf("Error: failed to write image file: %q", err)
+                        glog.Errorf("failed to write image file: %q", err)
                 }
         }
 }
 
 // Titlebar is used in titlebar template expansion.
 type Titlebar struct {
         GitHash string
         GitInfo string
 }
 
@@ skipping 72 matching lines @@
         Message string `json:"message"`
         StdOut  string `json:"stdout"`
         Img     string `json:"img"`
         Hash    string `json:"hash"`
 }
 
 // doCmd executes the given command line string; the command being
 // run is expected to not care what its current working directory is.
 // Returns the stdout and stderr.
 func doCmd(commandLine string) (string, error) {
-        log.Printf("Command: %q\n", commandLine)
+        glog.Infof("Command: %q\n", commandLine)
         programAndArgs := strings.SplitN(commandLine, " ", 2)
         program := programAndArgs[0]
         args := []string{}
         if len(programAndArgs) > 1 {
                 args = strings.Split(programAndArgs[1], " ")
         }
         cmd := exec.Command(program, args...)
         message, err := cmd.CombinedOutput()
-        log.Printf("StdOut + StdErr: %s\n", string(message))
+        glog.Infof("StdOut + StdErr: %s\n", string(message))
         if err != nil {
-                log.Printf("Exit status: %s\n", err.Error())
+                glog.Errorf("Exit status: %s\n", err)
                 return string(message), fmt.Errorf("Failed to run command.")
         }
         return string(message), nil
 }
 
 // reportError formats an HTTP error response and also logs the detailed error message.
 func reportError(w http.ResponseWriter, r *http.Request, err error, message string) {
-        log.Printf("Error: %s\n%s", message, err.Error())
+        glog.Errorf("%s\n%s", message, err)
         w.Header().Set("Content-Type", "text/plain")
         http.Error(w, message, 500)
 }
 
 // reportTryError formats an HTTP error response in JSON and also logs the detailed error message.
 func reportTryError(w http.ResponseWriter, r *http.Request, err error, message, hash string) {
         m := response{
                 Message: message,
                 Hash:    hash,
         }
-        log.Printf("Error: %s\n%s", message, err.Error())
+        glog.Errorf("%s\n%s", message, err)
         resp, err := json.Marshal(m)
         if err != nil {
                 http.Error(w, "Failed to serialize a response", 500)
                 return
         }
         w.Header().Set("Content-Type", "text/plain")
         w.Write(resp)
 }
 
 func writeToDatabase(hash string, code string, workspaceName string, source int, width, height int, gpu bool) {
         if db == nil {
                 return
         }
         if _, err := db.Exec("INSERT INTO webtry (code, hash, width, height, gpu, source_image_id) VALUES(?, ?, ?, ?, ?, ?)", code, hash, width, height, gpu, source); err != nil {
-                log.Printf("ERROR: Failed to insert code into database: %q\n", err)
+                glog.Errorf("Failed to insert code into database: %q\n", err)
         }
         if workspaceName != "" {
                 if _, err := db.Exec("INSERT INTO workspacetry (name, hash, width, height, gpu, source_image_id) VALUES(?, ?, ?, ?, ?, ?)", workspaceName, hash, width, height, gpu, source); err != nil {
-                        log.Printf("ERROR: Failed to insert into workspacetry table: %q\n", err)
+                        glog.Errorf("Failed to insert into workspacetry table: %q\n", err)
                 }
         }
 }
 
 type Sources struct {
         Id int `json:"id"`
 }
 
 // sourcesHandler serves up the PNG of a specific try.
 func sourcesHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("Sources Handler: %q\n", r.URL.Path)
+        glog.Infof("Sources Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 rows, err := db.Query("SELECT id, create_ts FROM source_images WHERE hidden=0 ORDER BY create_ts DESC")
 
                 if err != nil {
                         http.Error(w, fmt.Sprintf("Failed to query sources: %s.", err), 500)
                 }
                 sources := make([]Sources, 0, 0)
                 for rows.Next() {
                         var id int
                         var create_ts time.Time
                         if err := rows.Scan(&id, &create_ts); err != nil {
-                                log.Printf("Error: failed to fetch from database: %q", err)
+                                glog.Errorf("failed to fetch from database: %q", err)
                                 continue
                         }
                         sources = append(sources, Sources{Id: id})
                 }
 
                 resp, err := json.Marshal(sources)
                 if err != nil {
                         reportError(w, r, err, "Failed to serialize a response.")
                         return
                 }
@@ skipping 23 matching lines @@
                 if err != nil {
                         http.Error(w, fmt.Sprintf("Failed to decode image: %s.", err), 500)
                         return
                 }
                 var b bytes.Buffer
                 png.Encode(&b, m)
                 bounds := m.Bounds()
                 width := bounds.Max.Y - bounds.Min.Y
                 height := bounds.Max.X - bounds.Min.X
                 if _, err := db.Exec("INSERT INTO source_images (image, width, height) VALUES(?, ?, ?)", b.Bytes(), width, height); err != nil {
-                        log.Printf("ERROR: Failed to insert sources into database: %q\n", err)
+                        glog.Errorf("Failed to insert sources into database: %q\n", err)
                         http.Error(w, fmt.Sprintf("Failed to store image: %s.", err), 500)
                         return
                 }
                 go writeOutAllSourceImages()
 
                 // Now redirect back to where we came from.
                 http.Redirect(w, r, r.Referer(), 302)
         } else {
                 http.NotFound(w, r)
                 return
         }
 }
 
 // imageHandler serves up the PNG of a specific try.
 func imageHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("Image Handler: %q\n", r.URL.Path)
+        glog.Infof("Image Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := imageLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         filename := match[1]
         w.Header().Set("Content-Type", "image/png")
         http.ServeFile(w, r, fmt.Sprintf("../../../inout/%s", filename))
 }
 
 type Try struct {
         Hash     string `json:"hash"`
         Source   int
         CreateTS string `json:"create_ts"`
 }
 
 type Recent struct {
         Tries    []Try
         Titlebar Titlebar
 }
 
 // recentHandler shows the last 20 tries.
 func recentHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("Recent Handler: %q\n", r.URL.Path)
+        glog.Infof("Recent Handler: %q\n", r.URL.Path)
 
         var err error
         rows, err := db.Query("SELECT create_ts, hash FROM webtry ORDER BY create_ts DESC LIMIT 20")
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         recent := []Try{}
         for rows.Next() {
                 var hash string
                 var create_ts time.Time
                 if err := rows.Scan(&create_ts, &hash); err != nil {
-                        log.Printf("Error: failed to fetch from database: %q", err)
+                        glog.Errorf("failed to fetch from database: %q", err)
                         continue
                 }
                 recent = append(recent, Try{Hash: hash, CreateTS: create_ts.Format("2006-02-01")})
         }
         w.Header().Set("Content-Type", "text/html")
         if err := recentTemplate.Execute(w, Recent{Tries: recent, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
-                log.Printf("ERROR: Failed to expand template: %q\n", err)
+                glog.Errorf("Failed to expand template: %q\n", err)
         }
 }
 
 type Workspace struct {
         Name     string
         Code     string
         Hash     string
         Width    int
         Height   int
         Source   int
         GPU      bool
         Tries    []Try
         Titlebar Titlebar
 }
 
 // newWorkspace generates a new random workspace name and stores it in the database.
 func newWorkspace() (string, error) {
         for i := 0; i < 10; i++ {
                 adj := workspaceNameAdj[rand.Intn(len(workspaceNameAdj))]
                 noun := workspaceNameNoun[rand.Intn(len(workspaceNameNoun))]
                 suffix := rand.Intn(1000)
                 name := fmt.Sprintf("%s-%s-%d", adj, noun, suffix)
                 if _, err := db.Exec("INSERT INTO workspace (name) VALUES(?)", name); err == nil {
                         return name, nil
                 } else {
-                        log.Printf("ERROR: Failed to insert workspace into database: %q\n", err)
+                        glog.Errorf("Failed to insert workspace into database: %q\n", err)
                 }
         }
         return "", fmt.Errorf("Failed to create a new workspace")
 }
 
 // getCode returns the code for a given hash, or the empty string if not found.
 func getCode(hash string) (string, int, int, int, bool, error) {
         code := ""
         width := 0
         height := 0
         source := 0
         gpu := false
         if err := db.QueryRow("SELECT code, width, height, gpu, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &gpu, &source); err != nil {
-                log.Printf("ERROR: Code for hash is missing: %q\n", err)
+                glog.Errorf("Code for hash is missing: %q\n", err)
                 return code, width, height, source, gpu, err
         }
         return code, width, height, source, gpu, nil
 }
 
 func workspaceHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("Workspace Handler: %q\n", r.URL.Path)
+        glog.Infof("Workspace Handler: %q\n", r.URL.Path)
         if r.Method == "GET" {
                 tries := []Try{}
                 match := workspaceLink.FindStringSubmatch(r.URL.Path)
                 name := ""
                 if len(match) == 2 {
                         name = match[1]
                         rows, err := db.Query("SELECT create_ts, hash, source_image_id FROM workspacetry WHERE name=? ORDER BY create_ts", name)
                         if err != nil {
                                 reportError(w, r, err, "Failed to select.")
                                 return
                         }
                         for rows.Next() {
                                 var hash string
                                 var create_ts time.Time
                                 var source int
                                 if err := rows.Scan(&create_ts, &hash, &source); err != nil {
-                                        log.Printf("Error: failed to fetch from database: %q", err)
+                                        glog.Errorf("failed to fetch from database: %q", err)
                                         continue
                                 }
                                 tries = append(tries, Try{Hash: hash, Source: source, CreateTS: create_ts.Format("2006-02-01")})
                         }
                 }
                 var code string
                 var hash string
                 var width int
                 var height int
                 source := 0
                 gpu := false
                 if len(tries) == 0 {
                         code = DEFAULT_SAMPLE
                         width = 256
                         height = 256
                 } else {
                         hash = tries[len(tries)-1].Hash
                         code, width, height, source, gpu, _ = getCode(hash)
                 }
                 w.Header().Set("Content-Type", "text/html")
                 if err := workspaceTemplate.Execute(w, Workspace{Tries: tries, Code: code, Name: name, Hash: hash, Width: width, Height: height, GPU: gpu, Source: source, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
-                        log.Printf("ERROR: Failed to expand template: %q\n", err)
+                        glog.Errorf("Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 name, err := newWorkspace()
                 if err != nil {
                         http.Error(w, "Failed to create a new workspace.", 500)
                         return
                 }
                 http.Redirect(w, r, "/w/"+name, 302)
         }
 }
@@ skipping 13 matching lines @@
         Code   string `json:"code"`
         Width  int    `json:"width"`
         Height int    `json:"height"`
         GPU    bool   `json:"gpu"`
         Name   string `json:"name"`   // Optional name of the workspace the code is in.
         Source int    `json:"source"` // ID of the source image, 0 if none.
 }
 
 // iframeHandler handles the GET and POST of the main page.
 func iframeHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("IFrame Handler: %q\n", r.URL.Path)
+        glog.Infof("IFrame Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := iframeLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
         if db == nil {
                 http.NotFound(w, r)
                 return
         }
         var code string
         code, width, height, source, gpu, err := getCode(hash)
         if err != nil {
                 http.NotFound(w, r)
                 return
         }
         // Expand the template.
         w.Header().Set("Content-Type", "text/html")
         if err := iframeTemplate.Execute(w, userCode{Code: code, Width: width, Height: height, GPU: gpu, Hash: hash, Source: source}); err != nil {
-                log.Printf("ERROR: Failed to expand template: %q\n", err)
+                glog.Errorf("Failed to expand template: %q\n", err)
         }
 }
 
 type TryInfo struct {
         Hash   string `json:"hash"`
         Code   string `json:"code"`
         Width  int    `json:"width"`
         Height int    `json:"height"`
         GPU    bool   `json:"gpu"`
         Source int    `json:"source"`
 }
 
 // tryInfoHandler returns information about a specific try.
 func tryInfoHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("Try Info Handler: %q\n", r.URL.Path)
+        glog.Infof("Try Info Handler: %q\n", r.URL.Path)
         if r.Method != "GET" {
                 http.NotFound(w, r)
                 return
         }
         match := tryInfoLink.FindStringSubmatch(r.URL.Path)
         if len(match) != 2 {
                 http.NotFound(w, r)
                 return
         }
         hash := match[1]
@@ skipping 14 matching lines @@
         if err != nil {
                 reportError(w, r, err, "Failed to serialize a response.")
                 return
         }
         w.Header().Set("Content-Type", "application/json")
         w.Write(resp)
 }
 
 func cleanCompileOutput(s, hash string) string {
         old := "../../../cache/src/" + hash + ".cpp:"
-        log.Printf("INFO: replacing %q\n", old)
+        glog.Infof("replacing %q\n", old)
         return strings.Replace(s, old, "usercode.cpp:", -1)
 }
 
 // mainHandler handles the GET and POST of the main page.
 func mainHandler(w http.ResponseWriter, r *http.Request) {
-        log.Printf("Main Handler: %q\n", r.URL.Path)
+        glog.Infof("Main Handler: %q\n", r.URL.Path)
         requestsCounter.Inc(1)
         if r.Method == "GET" {
                 code := DEFAULT_SAMPLE
                 source := 0
                 width := 256
                 height := 256
                 gpu := false
                 match := directLink.FindStringSubmatch(r.URL.Path)
                 var hash string
                 if len(match) == 2 && r.URL.Path != "/" {
                         hash = match[1]
                         if db == nil {
                                 http.NotFound(w, r)
                                 return
                         }
                         // Update 'code' with the code found in the database.
                         if err := db.QueryRow("SELECT code, width, height, gpu, source_image_id FROM webtry WHERE hash=?", hash).Scan(&code, &width, &height, &gpu, &source); err != nil {
                                 http.NotFound(w, r)
                                 return
                         }
                 }
                 // Expand the template.
                 w.Header().Set("Content-Type", "text/html")
                 if err := indexTemplate.Execute(w, userCode{Code: code, Hash: hash, Source: source, Width: width, Height: height, GPU: gpu, Titlebar: Titlebar{GitHash: gitHash, GitInfo: gitInfo}}); err != nil {
-                        log.Printf("ERROR: Failed to expand template: %q\n", err)
+                        glog.Errorf("Failed to expand template: %q\n", err)
                 }
         } else if r.Method == "POST" {
                 w.Header().Set("Content-Type", "application/json")
                 buf := bytes.NewBuffer(make([]byte, 0, MAX_TRY_SIZE))
                 n, err := buf.ReadFrom(r.Body)
                 if err != nil {
                         reportTryError(w, r, err, "Failed to read a request body.", "")
                         return
                 }
                 if n == MAX_TRY_SIZE {
@@ skipping 67 matching lines @@
         http.HandleFunc("/iframe/", autogzip.HandleFunc(iframeHandler))
         http.HandleFunc("/json/", autogzip.HandleFunc(tryInfoHandler))
         http.HandleFunc("/sources/", autogzip.HandleFunc(sourcesHandler))
 
         // Resources are served directly
         // TODO add support for caching/etags/gzip
         http.Handle("/res/", autogzip.Handle(http.FileServer(http.Dir("./"))))
 
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", autogzip.HandleFunc(mainHandler))
-        log.Fatal(http.ListenAndServe(*port, nil))
+        glog.Fatal(http.ListenAndServe(*port, nil))
 }