go: Replace Logrus with go-logging.

go/src/infra/monitoring/dispatcher/dispatcher.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Dispatcher usage:
 // go run infra/monitoring/dispatcher
 // Expects gatekeeper.json to be in the current directory.
 // Runs a single check, prints out diagnosis and exits.
 // TODO(seanmccullough): Run continuously.  Also, consider renaming to 'patrol'
 // or 'scanner' because that's really what this thing does.
 
 package main
 
 import (
         "encoding/json"
         "flag"
         "fmt"
         "io/ioutil"
         "os"
         "strings"
         "time"
 
-        "github.com/Sirupsen/logrus"
+        "infra/libs/logging"
 
         "infra/monitoring/analyzer"
         "infra/monitoring/messages"
 )
 
 var (
         dataURL             = flag.String("data_url", "", "Url where alerts are stored")
         masterFilter        = flag.String("master-filter", "", "Filter out masters that contain this string")
         masterOnly          = flag.String("master", "", "Only check this master")
         mastersOnly         = flag.Bool("masters-only", false, "Just check for master alerts, not builders")
         gatekeeperJSON      = flag.String("gatekeeper", "gatekeeper.json", "Location of gatekeeper json file")
         gatekeeperTreesJSON = flag.String("gatekeeper-trees", "gatekeeper_trees.json", "Location of gatekeeper json file")
         treeOnly            = flag.String("tree", "", "Only check this tree")
         builderOnly         = flag.String("builder", "", "Only check this builder")
         buildOnly           = flag.Int64("build", 0, "Only check this build")
 
-        log = logrus.New()
+        log = logging.DefaultLogger
 
         // gk is the gatekeeper config.
         gk = &struct {
                 // Weird. Are there ever multiple configs per master key?
                 Masters map[string][]messages.MasterConfig `json:"masters"`
         }{}
         // gkt is the gatekeeper trees config.
         gkt              = map[string]messages.TreeMasterConfig{}
         filteredFailures = uint64(0)
 )
@@ skipping 36 matching lines @@
         start := time.Now()
         flag.Parse()
 
         masterNames := []string{}
         if *masterOnly != "" {
                 masterNames = append(masterNames, *masterOnly)
         }
 
         err := readJSONFile(*gatekeeperJSON, &gk)
         if err != nil {
-                log.Fatalf("Error reading gatekeeper json: %v", err)
+                log.Errorf("Error reading gatekeeper json: %v", err)
+                os.Exit(1)
         }
 
         err = readJSONFile(*gatekeeperTreesJSON, &gkt)
         if err != nil {
-                log.Fatalf("Error reading gatekeeper json: %v", err)
+                log.Errorf("Error reading gatekeeper json: %v", err)
+                os.Exit(1)
         }
 
         a := analyzer.New(nil, 2, 5)
 
         for masterURL, masterCfgs := range gk.Masters {
                 if len(masterCfgs) != 1 {
-                        log.Fatalf("Multiple configs for master: %s", masterURL)
+                        log.Errorf("Multiple configs for master: %s", masterURL)
+                        os.Exit(1)
                 }
                 masterName := masterFromURL(masterURL)
                 a.MasterCfgs[masterName] = masterCfgs[0]
         }
 
         a.TreeOnly = *treeOnly
         a.MasterOnly = *masterOnly
         a.BuilderOnly = *builderOnly
         a.BuildOnly = *buildOnly
 
         if *treeOnly != "" {
                 if t, ok := gkt[*treeOnly]; ok {
                         for _, url := range t.Masters {
                                 masterNames = append(masterNames, masterFromURL(url))
                         }
                 } else {
-                        log.Fatalf("Unrecoginzed tree: %s", *treeOnly)
+                        log.Errorf("Unrecoginzed tree: %s", *treeOnly)
+                        os.Exit(1)
                 }
         }
 
         bes, errs := a.Client.BuildExtracts(masterNames)
         log.Infof("Build Extracts read: %d", len(bes))
         log.Infof("Errors: %d", len(errs))
         for url, err := range errs {
                 log.Errorf("Error reading build extract from %s : %s", url, err)
         }
 
@@ skipping 19 matching lines @@
                 }
         }
 
         log.Infof("Filtered failures: %v", filteredFailures)
         a.Client.DumpStats()
         log.Infof("Elapsed time: %v", time.Since(start))
         if len(errs) > 0 {
                 os.Exit(1)
         }
 }