1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.log;
import com.yahoo.log.event.Event;
import com.yahoo.log.event.MalformedEventException;
import java.time.Instant;
import java.util.OptionalLong;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* This class implements the common ground log message used by
* the logserver. A LogMessage is immutable. Note that we have
* chosen the name LogMessage to avoid confusion with LogRecord
* which is used in java.util.logging.
*
* @author Bjorn Borud
* @author bjorncs
*/
public class LogMessage
{
private static Logger log = Logger.getLogger(LogMessage.class.getName());
private static Pattern nativeFormat =
Pattern.compile("^(\\d[^\t]+)\t" + // time
"([^\t]+)\t" + // host
"([^\t]+)\t" + // threadProcess
"([^\t]+)\t" + // service
"([^\t]+)\t" + // component
"([^\t]+)\t" + // level
"(.+)$" // payload
);
private Instant time;
private String host;
private long processId;
private long threadId;
private String service;
private String component;
private Level level;
private String payload;
private Event event;
/**
* Private constructor. Log messages should never be instantiated
* directly; only as the result of a static factory method.
*/
private LogMessage (Instant time, String host, long processId, long threadId,
String service, String component, Level level,
String payload)
{
this.time = time;
this.host = host;
this.processId = processId;
this.threadId = threadId;
this.service = service;
this.component = component;
this.level = level;
this.payload = payload;
}
public static LogMessage of(
Instant time, String host, long processId, long threadId,
String service, String component, Level level, String payload) {
return new LogMessage(time, host, processId, threadId, service, component, level, payload);
}
public Instant getTimestamp() {return time;}
/**
* @deprecated Use {@link #getTimestamp()}
*/
@Deprecated(since = "7", forRemoval = true)
public long getTime () {return time.toEpochMilli();}
/**
* @deprecated Use {@link #getTimestamp()}
*/
@Deprecated(since = "7", forRemoval = true)
public long getTimeInSeconds () {return time.getEpochSecond();}
public String getHost () {return host;}
public long getProcessId() {return processId;}
public OptionalLong getThreadId() {return threadId != -1 ? OptionalLong.of(threadId) : OptionalLong.empty();}
/**
* @deprecated Use {@link #getProcessId()} / {@link #getThreadId()}
*/
@Deprecated(since = "7", forRemoval = true)
public String getThreadProcess () {return VespaFormat.formatThreadProcess(processId, threadId);}
public String getService () {return service;}
public String getComponent () {return component;}
public Level getLevel () {return level;}
public String getPayload () {return payload;}
/**
* Make a log message from the native format of the logging
* package.
*
* @param msg The log message
* @return Returns a LogMessage instance
* @throws InvalidLogFormatException if the log message
* can not be parsed, ie. is invalid, we throw this
* exception.
*/
public static LogMessage parseNativeFormat(String msg) throws InvalidLogFormatException {
Matcher m = nativeFormat.matcher(msg);
if (! m.matches()) {
throw new InvalidLogFormatException(msg);
}
Level msgLevel = LogLevel.parse(m.group(6));
Instant timestamp = parseTimestamp(m.group(1));
String threadProcess = m.group(3);
return new LogMessage(timestamp, m.group(2), parseProcessId(threadProcess), parseThreadId(threadProcess),
m.group(4), m.group(5), msgLevel,
m.group(7));
}
private static Instant parseTimestamp(String timeStr) throws InvalidLogFormatException {
try {
long nanoseconds = (long) (Double.parseDouble(timeStr) * 1_000_000_000L);
return Instant.ofEpochSecond(0, nanoseconds);
} catch (NumberFormatException e) {
throw new InvalidLogFormatException("Invalid time string: " + timeStr);
}
}
private static long parseProcessId(String threadProcess) {
int slashIndex = threadProcess.indexOf('/');
if (slashIndex == -1) {
return Long.parseLong(threadProcess);
}
return Long.parseLong(threadProcess.substring(0, slashIndex));
}
private static long parseThreadId(String threadProcess) {
int slashIndex = threadProcess.indexOf('/');
if (slashIndex == -1) {
return -1;
}
return Long.parseLong(threadProcess.substring(slashIndex + 1));
}
/**
* If the LogMessage was an EVENT then this method can
* be used to get the Event instance representing the
* event. The event instance created the first time
* this method is called and then cached.
*
* TODO: make sure this throws exception!
*
* @return Returns Event instance if this is an event message
* and the payload is correctly formatted. Otherwise
* it will return <code>null</code>.
*
*/
public Event getEvent () throws MalformedEventException {
if ((level == LogLevel.EVENT) && (event == null)) {
try {
event = Event.parse(getPayload());
event.setTime(time.toEpochMilli());
}
catch (MalformedEventException e) {
log.log(LogLevel.DEBUG, "Got malformed event: " + getPayload());
throw e;
}
}
return event;
}
/**
* Return valid representation of log message.
*/
public String toString () {
String threadProcess = VespaFormat.formatThreadProcess(processId, threadId);
String timeStr = VespaFormat.formatTime(time);
return new StringBuilder(timeStr.length()
+ host.length()
+ threadProcess.length()
+ service.length()
+ component.length()
+ level.toString().length()
+ payload.length()
+ 1)
.append(timeStr).append("\t")
.append(host).append("\t")
.append(threadProcess).append("\t")
.append(service).append("\t")
.append(component).append("\t")
.append(level.toString().toLowerCase()).append("\t")
.append(payload).append("\n")
.toString();
}
}
|