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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
// Copyright Vespa.ai. 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.Objects;
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;}
public String getHost () {return host;}
public long getProcessId() {return processId;}
public OptionalLong getThreadId() {return threadId > 0 ? OptionalLong.of(threadId) : OptionalLong.empty();}
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);
}
@SuppressWarnings("deprecation")
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 {
int decimalSeparator = timeStr.indexOf('.');
if (decimalSeparator == -1) {
return Instant.ofEpochSecond(Long.parseLong(timeStr));
}
long seconds = Long.parseLong(timeStr.substring(0, decimalSeparator));
long nanoseconds = Long.parseLong(String.format("%1$-9s", timeStr.substring(decimalSeparator + 1)).replace(' ', '0')); // right pad with zeros
return Instant.ofEpochSecond(seconds, nanoseconds);
} catch (NumberFormatException e) {
throw new InvalidLogFormatException(String.format("Failed to parse timestamp: %s. Timestamp string: '%s'", e.getMessage(), timeStr), e);
}
}
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 0;
}
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>.
*
*/
@SuppressWarnings("deprecation")
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()
+ 7)
.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();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
LogMessage that = (LogMessage) o;
return processId == that.processId &&
threadId == that.threadId &&
Objects.equals(time, that.time) &&
Objects.equals(host, that.host) &&
Objects.equals(service, that.service) &&
Objects.equals(component, that.component) &&
Objects.equals(level, that.level) &&
Objects.equals(payload, that.payload) &&
Objects.equals(event, that.event);
}
@Override
public int hashCode() {
return Objects.hash(time, host, processId, threadId, service, component, level, payload, event);
}
}
|
