vendor/google.golang.org/grpc/grpclog/grpclog.go

   1 /*
   2  *
   3  * Copyright 2017 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 // Package grpclog defines logging for grpc.
  20 //
  21 // All logs in transport package only go to verbose level 2.
  22 // All logs in other packages in grpc are logged in spite of the verbosity level.
  23 //
  24 // In the default logger,
  25 // severity level can be set by environment variable GRPC_GO_LOG_SEVERITY_LEVEL,
  26 // verbosity level can be set by GRPC_GO_LOG_VERBOSITY_LEVEL.
  27 package grpclog // import "google.golang.org/grpc/grpclog"
  28
  29 import "os"
  30
  31 var logger = newLoggerV2()
  32
  33 // V reports whether verbosity level l is at least the requested verbose level.
  34 func V(l int) bool {
  35         return logger.V(l)
  36 }
  37
  38 // Info logs to the INFO log.
  39 func Info(args ...interface{}) {
  40         logger.Info(args...)
  41 }
  42
  43 // Infof logs to the INFO log. Arguments are handled in the manner of fmt.Printf.
  44 func Infof(format string, args ...interface{}) {
  45         logger.Infof(format, args...)
  46 }
  47
  48 // Infoln logs to the INFO log. Arguments are handled in the manner of fmt.Println.
  49 func Infoln(args ...interface{}) {
  50         logger.Infoln(args...)
  51 }
  52
  53 // Warning logs to the WARNING log.
  54 func Warning(args ...interface{}) {
  55         logger.Warning(args...)
  56 }
  57
  58 // Warningf logs to the WARNING log. Arguments are handled in the manner of fmt.Printf.
  59 func Warningf(format string, args ...interface{}) {
  60         logger.Warningf(format, args...)
  61 }
  62
  63 // Warningln logs to the WARNING log. Arguments are handled in the manner of fmt.Println.
  64 func Warningln(args ...interface{}) {
  65         logger.Warningln(args...)
  66 }
  67
  68 // Error logs to the ERROR log.
  69 func Error(args ...interface{}) {
  70         logger.Error(args...)
  71 }
  72
  73 // Errorf logs to the ERROR log. Arguments are handled in the manner of fmt.Printf.
  74 func Errorf(format string, args ...interface{}) {
  75         logger.Errorf(format, args...)
  76 }
  77
  78 // Errorln logs to the ERROR log. Arguments are handled in the manner of fmt.Println.
  79 func Errorln(args ...interface{}) {
  80         logger.Errorln(args...)
  81 }
  82
  83 // Fatal logs to the FATAL log. Arguments are handled in the manner of fmt.Print.
  84 // It calls os.Exit() with exit code 1.
  85 func Fatal(args ...interface{}) {
  86         logger.Fatal(args...)
  87         // Make sure fatal logs will exit.
  88         os.Exit(1)
  89 }
  90
  91 // Fatalf logs to the FATAL log. Arguments are handled in the manner of fmt.Printf.
  92 // It calles os.Exit() with exit code 1.
  93 func Fatalf(format string, args ...interface{}) {
  94         logger.Fatalf(format, args...)
  95         // Make sure fatal logs will exit.
  96         os.Exit(1)
  97 }
  98
  99 // Fatalln logs to the FATAL log. Arguments are handled in the manner of fmt.Println.
 100 // It calle os.Exit()) with exit code 1.
 101 func Fatalln(args ...interface{}) {
 102         logger.Fatalln(args...)
 103         // Make sure fatal logs will exit.
 104         os.Exit(1)
 105 }
 106
 107 // Print prints to the logger. Arguments are handled in the manner of fmt.Print.
 108 //
 109 // Deprecated: use Info.
 110 func Print(args ...interface{}) {
 111         logger.Info(args...)
 112 }
 113
 114 // Printf prints to the logger. Arguments are handled in the manner of fmt.Printf.
 115 //
 116 // Deprecated: use Infof.
 117 func Printf(format string, args ...interface{}) {
 118         logger.Infof(format, args...)
 119 }
 120
 121 // Println prints to the logger. Arguments are handled in the manner of fmt.Println.
 122 //
 123 // Deprecated: use Infoln.
 124 func Println(args ...interface{}) {
 125         logger.Infoln(args...)
 126 }