cubefs

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 and grpclb packages 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 (
30
	"os"
31

32
	"google.golang.org/grpc/internal/grpclog"
33
)
34

35
func init() {
36
	SetLoggerV2(newLoggerV2())
37
}
38

39
// V reports whether verbosity level l is at least the requested verbose level.
40
func V(l int) bool {
41
	return grpclog.Logger.V(l)
42
}
43

44
// Info logs to the INFO log.
45
func Info(args ...interface{}) {
46
	grpclog.Logger.Info(args...)
47
}
48

49
// Infof logs to the INFO log. Arguments are handled in the manner of fmt.Printf.
50
func Infof(format string, args ...interface{}) {
51
	grpclog.Logger.Infof(format, args...)
52
}
53

54
// Infoln logs to the INFO log. Arguments are handled in the manner of fmt.Println.
55
func Infoln(args ...interface{}) {
56
	grpclog.Logger.Infoln(args...)
57
}
58

59
// Warning logs to the WARNING log.
60
func Warning(args ...interface{}) {
61
	grpclog.Logger.Warning(args...)
62
}
63

64
// Warningf logs to the WARNING log. Arguments are handled in the manner of fmt.Printf.
65
func Warningf(format string, args ...interface{}) {
66
	grpclog.Logger.Warningf(format, args...)
67
}
68

69
// Warningln logs to the WARNING log. Arguments are handled in the manner of fmt.Println.
70
func Warningln(args ...interface{}) {
71
	grpclog.Logger.Warningln(args...)
72
}
73

74
// Error logs to the ERROR log.
75
func Error(args ...interface{}) {
76
	grpclog.Logger.Error(args...)
77
}
78

79
// Errorf logs to the ERROR log. Arguments are handled in the manner of fmt.Printf.
80
func Errorf(format string, args ...interface{}) {
81
	grpclog.Logger.Errorf(format, args...)
82
}
83

84
// Errorln logs to the ERROR log. Arguments are handled in the manner of fmt.Println.
85
func Errorln(args ...interface{}) {
86
	grpclog.Logger.Errorln(args...)
87
}
88

89
// Fatal logs to the FATAL log. Arguments are handled in the manner of fmt.Print.
90
// It calls os.Exit() with exit code 1.
91
func Fatal(args ...interface{}) {
92
	grpclog.Logger.Fatal(args...)
93
	// Make sure fatal logs will exit.
94
	os.Exit(1)
95
}
96

97
// Fatalf logs to the FATAL log. Arguments are handled in the manner of fmt.Printf.
98
// It calls os.Exit() with exit code 1.
99
func Fatalf(format string, args ...interface{}) {
100
	grpclog.Logger.Fatalf(format, args...)
101
	// Make sure fatal logs will exit.
102
	os.Exit(1)
103
}
104

105
// Fatalln logs to the FATAL log. Arguments are handled in the manner of fmt.Println.
106
// It calle os.Exit()) with exit code 1.
107
func Fatalln(args ...interface{}) {
108
	grpclog.Logger.Fatalln(args...)
109
	// Make sure fatal logs will exit.
110
	os.Exit(1)
111
}
112

113
// Print prints to the logger. Arguments are handled in the manner of fmt.Print.
114
//
115
// Deprecated: use Info.
116
func Print(args ...interface{}) {
117
	grpclog.Logger.Info(args...)
118
}
119

120
// Printf prints to the logger. Arguments are handled in the manner of fmt.Printf.
121
//
122
// Deprecated: use Infof.
123
func Printf(format string, args ...interface{}) {
124
	grpclog.Logger.Infof(format, args...)
125
}
126

127
// Println prints to the logger. Arguments are handled in the manner of fmt.Println.
128
//
129
// Deprecated: use Infoln.
130
func Println(args ...interface{}) {
131
	grpclog.Logger.Infoln(args...)
132
}
133