1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120
121. 121
122. 122
123. 123
124. 124
125. 125
126. 126
127. 127
128. 128
129. 129
130. 130
131. 131
132. 132
133. 133
134. 134
135. 135
136. 136
137. 137
138. 138
139. 139
140. 140
141. 141
142. 142

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

package log

import "os"

// Logger is the basic interface for logging
type Logger interface {
	LevelLogger
	Trace(format string, v ...interface{})
	IsTrace() bool
	Debug(format string, v ...interface{})
	IsDebug() bool
	Info(format string, v ...interface{})
	IsInfo() bool
	Warn(format string, v ...interface{})
	IsWarn() bool
	Error(format string, v ...interface{})
	ErrorWithSkip(skip int, format string, v ...interface{})
	IsError() bool
	Critical(format string, v ...interface{})
	CriticalWithSkip(skip int, format string, v ...interface{})
	IsCritical() bool
	Fatal(format string, v ...interface{})
	FatalWithSkip(skip int, format string, v ...interface{})
	IsFatal() bool
}

// LevelLogger is the simplest logging interface
type LevelLogger interface {
	Flush()
	Close()
	GetLevel() Level
	Log(skip int, level Level, format string, v ...interface{}) error
}

// SettableLogger is the interface of loggers which have subloggers
type SettableLogger interface {
	SetLogger(name, provider, config string) error
	DelLogger(name string) (bool, error)
}

// StacktraceLogger is a logger that can log stacktraces
type StacktraceLogger interface {
	GetStacktraceLevel() Level
}

// LevelLoggerLogger wraps a LevelLogger as a Logger
type LevelLoggerLogger struct {
	LevelLogger
}

// Trace records trace log
func (l *LevelLoggerLogger) Trace(format string, v ...interface{}) {
	l.Log(1, TRACE, format, v...)
}

// IsTrace returns true if the logger is TRACE
func (l *LevelLoggerLogger) IsTrace() bool {
	return l.GetLevel() <= TRACE
}

// Debug records debug log
func (l *LevelLoggerLogger) Debug(format string, v ...interface{}) {
	l.Log(1, DEBUG, format, v...)
}

// IsDebug returns true if the logger is DEBUG
func (l *LevelLoggerLogger) IsDebug() bool {
	return l.GetLevel() <= DEBUG
}

// Info records information log
func (l *LevelLoggerLogger) Info(format string, v ...interface{}) {
	l.Log(1, INFO, format, v...)
}

// IsInfo returns true if the logger is INFO
func (l *LevelLoggerLogger) IsInfo() bool {
	return l.GetLevel() <= INFO
}

// Warn records warning log
func (l *LevelLoggerLogger) Warn(format string, v ...interface{}) {
	l.Log(1, WARN, format, v...)
}

// IsWarn returns true if the logger is WARN
func (l *LevelLoggerLogger) IsWarn() bool {
	return l.GetLevel() <= WARN
}

// Error records error log
func (l *LevelLoggerLogger) Error(format string, v ...interface{}) {
	l.Log(1, ERROR, format, v...)
}

// ErrorWithSkip records error log from "skip" calls back from this function
func (l *LevelLoggerLogger) ErrorWithSkip(skip int, format string, v ...interface{}) {
	l.Log(skip+1, ERROR, format, v...)
}

// IsError returns true if the logger is ERROR
func (l *LevelLoggerLogger) IsError() bool {
	return l.GetLevel() <= ERROR
}

// Critical records critical log
func (l *LevelLoggerLogger) Critical(format string, v ...interface{}) {
	l.Log(1, CRITICAL, format, v...)
}

// CriticalWithSkip records critical log from "skip" calls back from this function
func (l *LevelLoggerLogger) CriticalWithSkip(skip int, format string, v ...interface{}) {
	l.Log(skip+1, CRITICAL, format, v...)
}

// IsCritical returns true if the logger is CRITICAL
func (l *LevelLoggerLogger) IsCritical() bool {
	return l.GetLevel() <= CRITICAL
}

// Fatal records fatal log and exit the process
func (l *LevelLoggerLogger) Fatal(format string, v ...interface{}) {
	l.Log(1, FATAL, format, v...)
	l.Close()
	os.Exit(1)
}

// FatalWithSkip records fatal log from "skip" calls back from this function and exits the process
func (l *LevelLoggerLogger) FatalWithSkip(skip int, format string, v ...interface{}) {
	l.Log(skip+1, FATAL, format, v...)
	l.Close()
	os.Exit(1)
}

// IsFatal returns true if the logger is FATAL
func (l *LevelLoggerLogger) IsFatal() bool {
	return l.GetLevel() <= FATAL
}