Debian Codegraph @

launcher/internal/logging/logging.go

raw
1 // Package logging implements a logger to be used in the client.
2 // Logs to both Cloud Logging and the serial console.
3 package logging
4
5 import (
6 "context"
7 "fmt"
8 "log/slog"
9 "os"
10
11 "cloud.google.com/go/compute/metadata"
12 clogging "cloud.google.com/go/logging"
13 mrpb "google.golang.org/genproto/googleapis/api/monitoredres"
14 )
15
16 const (
17 logName = "confidential-space-launcher"
18 serialConsoleFile = "/dev/console"
19
20 payloadMessageKey = "MESSAGE"
21 payloadInstanceNameKey = "_HOSTNAME"
22 )
23
24 // Logger defines the interface for the CS image logger.
25 type Logger interface {
26 Log(severity clogging.Severity, msg string, args ...any)
27
28 Info(msg string, args ...any)
29 Warn(msg string, args ...any)
30 Error(msg string, args ...any)
31
32 SerialConsoleFile() *os.File
33 Close()
34 }
35
36 type cLogger interface {
37 Log(clogging.Entry)
38 Flush() error
39 }
40
41 type logger struct {
42 cloudLogger cLogger
43 serialLogger *slog.Logger
44 resource *mrpb.MonitoredResource
45
46 instanceName string
47 cloudClient *clogging.Client
48 serialConsoleFile *os.File
49 }
50
51 type payload map[string]any
52
53 // NewLogger returns a Logger with Cloud and Serial Console logging configured.
54 func NewLogger(ctx context.Context) (Logger, error) {
55 // Retrieve monitored resource information.
56 mdsClient := metadata.NewClient(nil)
57
58 projectID, err := mdsClient.ProjectIDWithContext(ctx)
59 if err != nil {
60 return nil, err
61 }
62
63 instanceID, err := mdsClient.InstanceIDWithContext(ctx)
64 if err != nil {
65 return nil, err
66 }
67
68 instanceName, err := mdsClient.InstanceNameWithContext(ctx)
69 if err != nil {
70 return nil, err
71 }
72
73 zone, err := mdsClient.ZoneWithContext(ctx)
74 if err != nil {
75 return nil, err
76 }
77
78 // Configure Cloud Logging client/logger.
79 cloggingClient, err := clogging.NewClient(ctx, projectID)
80 if err != nil {
81 return nil, err
82 }
83
84 // Configure Serial Console logger.
85 serialConsole, err := os.OpenFile(serialConsoleFile, os.O_WRONLY, 0)
86 if err != nil {
87 return nil, fmt.Errorf("failed to open serial console for writing: %v", err)
88 }
89
90 slg := slog.New(slog.NewTextHandler(serialConsole, nil))
91 slg.Info("Serial Console logger initialized")
92
93 // This is necessary for DEBUG logs to propagate properly.
94 slog.SetDefault(slg)
95
96 return &logger{
97 cloudLogger: cloggingClient.Logger(logName),
98 serialLogger: slg,
99 resource: &mrpb.MonitoredResource{
100 Type: "gce_instance",
101 Labels: map[string]string{
102 "project_id": projectID,
103 "instance_id": instanceID,
104 "zone": zone,
105 },
106 },
107 instanceName: instanceName,
108 cloudClient: cloggingClient,
109 serialConsoleFile: serialConsole,
110 }, err
111 }
112
113 func (l *logger) SerialConsoleFile() *os.File {
114 return l.serialConsoleFile
115 }
116
117 func (l *logger) Close() {
118 if l.cloudClient != nil {
119 l.cloudClient.Close()
120 }
121
122 if l.serialConsoleFile != nil {
123 l.serialConsoleFile.Close()
124 }
125 }
126
127 // Given a list of args, recursively converts it to a payload.
128 // Assumes alternating keys and values (mirroring slog's behavior).
129 func addArgs(pl payload, args []any) {
130 // Base case - if args is empty.
131 if len(args) == 0 {
132 return
133 }
134
135 // Base case - if args has one element.
136 if len(args) == 1 {
137 // If the arg is a valid key, add with empty value.
138 key, ok := args[0].(string)
139 if ok {
140 pl[key] = ""
141 }
142 return
143 }
144
145 key, ok := args[0].(string)
146 if ok {
147 // If key is a valid string, add pair to payload. Otherwise, the pair is skipped.
148 pl[key] = args[1]
149 }
150
151 // Recurse with remaining args.
152 addArgs(pl, args[2:])
153 }
154
155 func (l *logger) writeLog(severity clogging.Severity, msg string, args ...any) {
156 // Write cloud log.
157 logEntry := clogging.Entry{
158 Severity: severity,
159 Resource: l.resource,
160 }
161
162 pl := payload{}
163 addArgs(pl, args)
164
165 if len(msg) > 0 {
166 pl[payloadMessageKey] = msg
167 }
168
169 if len(l.instanceName) > 0 {
170 // Needed for backwards compatibility with Cloudbuild tests.
171 pl[payloadInstanceNameKey] = l.instanceName
172 }
173
174 logEntry.Payload = pl
175
176 l.cloudLogger.Log(logEntry)
177 if err := l.cloudLogger.Flush(); err != nil {
178 l.serialLogger.Error(fmt.Sprintf("cloud.Logger.Flush returned error: %v", err))
179 }
180
181 // Write to serial console.
182 switch severity {
183 case clogging.Info, clogging.Notice, clogging.Debug:
184 l.serialLogger.Info(msg, args...)
185 case clogging.Warning:
186 l.serialLogger.Warn(msg, args...)
187 case clogging.Error, clogging.Critical, clogging.Alert, clogging.Emergency:
188 l.serialLogger.Error(msg, args...)
189 default:
190 slog.Debug(msg, args...)
191 }
192 }
193
194 // Log logs msg and args with the provided severity.
195 func (l *logger) Log(severity clogging.Severity, msg string, args ...any) {
196 l.writeLog(severity, msg, args...)
197 }
198
199 // Info logs msg and args at 'Info' severity.
200 func (l *logger) Info(msg string, args ...any) {
201 l.writeLog(clogging.Info, msg, args...)
202 }
203
204 // Warn logs msg and args at 'Warn' severity.
205 func (l *logger) Warn(msg string, args ...any) {
206 l.writeLog(clogging.Warning, msg, args...)
207 }
208
209 // Error logs msg and args at 'Error' severity.
210 func (l *logger) Error(msg string, args ...any) {
211 l.writeLog(clogging.Error, msg, args...)
212 }
213
214 // SimpleLogger returns a lightweight implementation that wraps a slog.Default() logger.
215 // Suitable for testing.
216 func SimpleLogger() Logger {
217 return &slogger{slog.Default()}
218 }
219
220 type slogger struct {
221 slg *slog.Logger
222 }
223
224 // Log logs msg and args with the provided severity.
225 func (l *slogger) Log(severity clogging.Severity, msg string, args ...any) {
226 level := slog.LevelDebug
227 switch severity {
228 case clogging.Info, clogging.Notice:
229 level = slog.LevelInfo
230 case clogging.Warning:
231 level = slog.LevelWarn
232 case clogging.Error, clogging.Critical, clogging.Alert, clogging.Emergency:
233 level = slog.LevelError
234 }
235 l.slg.Log(context.Background(), level, msg, args...)
236 }
237
238 // Info logs msg and args at 'Info' severity.
239 func (l *slogger) Info(msg string, args ...any) {
240 l.slg.Info(msg, args...)
241 }
242
243 // Warn logs msg and args at 'Warn' severity.
244 func (l *slogger) Warn(msg string, args ...any) {
245 l.slg.Warn(msg, args...)
246 }
247
248 // Error logs msg and args at 'Error' severity.
249 func (l *slogger) Error(msg string, args ...any) {
250 l.slg.Error(msg, args...)
251 }
252
253 func (l *slogger) SerialConsoleFile() *os.File {
254 return nil
255 }
256
257 func (l *slogger) Close() {}