@Override LogEntry parse(String... args) throws Exception { if (args.length >= 3) { if ((args.length & 0x1) != 0x1) { throw new IllegalArgumentException("Labels must be a list of key-value pairs."); } String logName = args[0]; Severity severity = Severity.valueOf(args[1].toUpperCase()); String message = args[2]; Map<String, String> labels = Maps.newHashMapWithExpectedSize((args.length - 3) / 2); for (int i = 3; i < args.length; i += 2) { labels.put(args[i], args[i + 1]); } return LogEntry.newBuilder(StringPayload.of(message)) .setLogName(logName) .setSeverity(severity) .setLabels(labels) .build(); } else { throw new IllegalArgumentException("Missing required arguments."); } }
/** * Example of writing log entries and providing a default log name and monitored resource. Logging * writes are asynchronous by default. {@link Logging#setWriteSynchronicity(Synchronicity)} can be * used to update the synchronicity. */ // [TARGET write(Iterable, WriteOption...)] // [VARIABLE "my_log_name"] public void write(String logName) { // [START logging_write_log_entry] List<LogEntry> entries = new ArrayList<>(); entries.add(LogEntry.of(StringPayload.of("Entry payload"))); Map<String, Object> jsonMap = new HashMap<>(); jsonMap.put("key", "value"); entries.add(LogEntry.of(JsonPayload.of(jsonMap))); logging.write( entries, WriteOption.logName(logName), WriteOption.resource(MonitoredResource.newBuilder("global").build())); // [END logging_write_log_entry] }
private LogEntry logEntryFor(LogRecord record) throws Exception { String payload = getFormatter().format(record); Level level = record.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload)) .setTimestamp(record.getMillis()) .setSeverity(severityFor(level)); if (!baseLevel.equals(level)) { builder .addLabel("levelName", level.getName()) .addLabel("levelValue", String.valueOf(level.intValue())); } for (LoggingEnhancer enhancer : enhancers) { enhancer.enhanceLogEntry(builder); } return builder.build(); }
private LogEntry logEntryFor(ILoggingEvent e) { StringBuilder payload = new StringBuilder(e.getFormattedMessage()).append('\n'); writeStack(e.getThrowableProxy(), "", payload); Level level = e.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload.toString().trim())) .setTimestamp(e.getTimeStamp()) .setSeverity(severityFor(level)); builder .addLabel(LEVEL_NAME_KEY, level.toString()) .addLabel(LEVEL_VALUE_KEY, String.valueOf(level.toInt())); if (loggingEnhancers != null) { for (LoggingEnhancer enhancer : loggingEnhancers) { enhancer.enhanceLogEntry(builder); } } if (loggingEventEnhancers != null) { for (LoggingEventEnhancer enhancer : loggingEventEnhancers) { enhancer.enhanceLogEntry(builder, e); } } return builder.build(); }
private LogEntry logEntryFor(LogRecord record) throws Exception { String payload = getFormatter().format(record); Level level = record.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload)) .setTimestamp(record.getMillis()) .setSeverity(severityFor(level)); if (!baseLevel.equals(level)) { builder .addLabel("levelName", level.getName()) .addLabel("levelValue", String.valueOf(level.intValue())); } for (LoggingEnhancer enhancer : enhancers) { enhancer.enhanceLogEntry(builder); } return builder.build(); }
static StringPayload fromPb(com.google.logging.v2.LogEntry entryPb) { return StringPayload.of(entryPb.getTextPayload()); } }
/** Expects a new or existing Stackdriver log name as the first argument.*/ public static void main(String... args) throws Exception { // Instantiates a client Logging logging = LoggingOptions.getDefaultInstance().getService(); // The name of the log to write to String logName = args[0]; // "my-log"; // The data to write to the log String text = "Hello, world!"; LogEntry entry = LogEntry.newBuilder(StringPayload.of(text)) .setSeverity(Severity.ERROR) .setLogName(logName) .setResource(MonitoredResource.newBuilder("global").build()) .build(); // Writes the log entry asynchronously logging.write(Collections.singleton(entry)); System.out.printf("Logged: %s%n", text); } }
LoggingOptions loggingOptions = logging().getOptions(); LogName logName = ProjectLogName.of(loggingOptions.getProjectId(), logId); StringPayload firstPayload = StringPayload.of("stringPayload"); LogEntry firstEntry = LogEntry.newBuilder(firstPayload)
LogEntry logEntry = LogEntry.newBuilder(STRING_PAYLOAD) .setPayload(StringPayload.of("otherPayload")) .setLogName(LOG_NAME) .setResource(RESOURCE) assertEquals(TRACE_SAMPLED, logEntry.getTraceSampled()); assertEquals(SOURCE_LOCATION, logEntry.getSourceLocation()); assertEquals(StringPayload.of("otherPayload"), logEntry.getPayload());
STRING_ENTRY .toBuilder() .setPayload(StringPayload.of("otherPayload")) .setLogName("otherLogName") .setResource(MonitoredResource.newBuilder("global").build()) assertEquals( new SourceLocation.Builder().setFile("hey.java").build(), logEntry.getSourceLocation()); assertEquals(StringPayload.of("otherPayload"), logEntry.getPayload()); logEntry = logEntry
@Test public void testFilterLogsOnlyLogsAtOrAboveLogLevel() { LogEntry logEntry = LogEntry.newBuilder(StringPayload.of("this is a test")) .setTimestamp(100000L) .setSeverity(Severity.ERROR)
@Test public void testEnhancersAddCorrectLabelsToLogEntries() { LogEntry logEntry = LogEntry.newBuilder(StringPayload.of("this is a test")) .setTimestamp(100000L) .setSeverity(Severity.WARNING) .setLabels( new ImmutableMap.Builder<String, String>() .put("levelName", "WARN") .put("levelValue", String.valueOf(30000L)) .put("test-label-1", "test-value-1") .put("test-label-2", "test-value-2") .build()) .build(); logging.setFlushSeverity(Severity.ERROR); Capture<Iterable<LogEntry>> capturedArgument = Capture.newInstance(); logging.write(capture(capturedArgument), (WriteOption) anyObject(), (WriteOption) anyObject()); expectLastCall().once(); replay(logging); loggingAppender.addEnhancer("com.example.enhancers.TestLoggingEnhancer"); loggingAppender.addEnhancer("com.example.enhancers.AnotherTestLoggingEnhancer"); loggingAppender.start(); Timestamp timestamp = Timestamp.ofTimeSecondsAndNanos(100000, 0); LoggingEvent loggingEvent = createLoggingEvent(Level.WARN, timestamp.getSeconds()); loggingAppender.doAppend(loggingEvent); verify(logging); assertThat(capturedArgument.getValue().iterator().hasNext()).isTrue(); assertThat(capturedArgument.getValue().iterator().next()).isEqualTo(logEntry); }
@Test public void testSyncWrite() { expect(options.getProjectId()).andReturn(PROJECT).anyTimes(); expect(options.getService()).andReturn(logging); LogEntry entry = LogEntry.newBuilder(Payload.StringPayload.of(MESSAGE)) .setSeverity(Severity.DEBUG) .addLabel("levelName", "FINEST") .addLabel("levelValue", String.valueOf(Level.FINEST.intValue())) .setTimestamp(123456789L) .build(); logging.setFlushSeverity(Severity.ERROR); expectLastCall().once(); logging.setWriteSynchronicity(Synchronicity.ASYNC); expectLastCall().once(); logging.setWriteSynchronicity(Synchronicity.SYNC); expectLastCall().once(); logging.write(ImmutableList.of(entry), DEFAULT_OPTIONS); expectLastCall().once(); replay(options, logging); LoggingHandler handler = new LoggingHandler(LOG_NAME, options, DEFAULT_RESOURCE); handler.setLevel(Level.ALL); handler.setSynchronicity(Synchronicity.SYNC); handler.setFormatter(new TestFormatter()); LogRecord record = new LogRecord(Level.FINEST, MESSAGE); record.setMillis(123456789L); handler.publish(record); }
@Test public void testFlushLevelConfigUpdatesLoggingFlushSeverity() { LogEntry logEntry = LogEntry.newBuilder(StringPayload.of("this is a test")) .setTimestamp(100000L) .setSeverity(Severity.WARNING) .setLabels( new ImmutableMap.Builder<String, String>() .put("levelName", "WARN") .put("levelValue", String.valueOf(30000L)) .build()) .build(); logging.setFlushSeverity(Severity.WARNING); Capture<Iterable<LogEntry>> capturedArgument = Capture.newInstance(); logging.write(capture(capturedArgument), (WriteOption) anyObject(), (WriteOption) anyObject()); replay(logging); Timestamp timestamp = Timestamp.ofTimeSecondsAndNanos(100000, 0); LoggingEvent loggingEvent = createLoggingEvent(Level.WARN, timestamp.getSeconds()); // error is the default, updating to warn for test loggingAppender.setFlushLevel(Level.WARN); loggingAppender.start(); loggingAppender.doAppend(loggingEvent); verify(logging); assertThat(capturedArgument.getValue().iterator().hasNext()).isTrue(); assertThat(capturedArgument.getValue().iterator().next()).isEqualTo(logEntry); }
public static void main(String... args) throws Exception { // Create a service object // Credentials are inferred from the environment LoggingOptions options = LoggingOptions.getDefaultInstance(); try (Logging logging = options.getService()) { // Create a log entry LogEntry firstEntry = LogEntry.newBuilder(StringPayload.of("message")) .setLogName("test-log") .setResource( MonitoredResource.newBuilder("global") .addLabel("project_id", options.getProjectId()) .build()) .build(); logging.write(Collections.singleton(firstEntry)); // List log entries Page<LogEntry> entries = logging.listLogEntries( EntryListOption.filter( "logName=projects/" + options.getProjectId() + "/logs/test-log")); for (LogEntry logEntry : entries.iterateAll()) { System.out.println(logEntry); } } } }
private LogEntry logEntryFor(ILoggingEvent e) { StringBuilder payload = new StringBuilder(e.getFormattedMessage()).append('\n'); writeStack(e.getThrowableProxy(), "", payload); Level level = e.getLevel(); LogEntry.Builder builder = LogEntry.newBuilder(Payload.StringPayload.of(payload.toString().trim())) .setTimestamp(e.getTimeStamp()) .setSeverity(severityFor(level)); builder .addLabel(LEVEL_NAME_KEY, level.toString()) .addLabel(LEVEL_VALUE_KEY, String.valueOf(level.toInt())); if (loggingEnhancers != null) { for (LoggingEnhancer enhancer : loggingEnhancers) { enhancer.enhanceLogEntry(builder); } } if (loggingEventEnhancers != null) { for (LoggingEventEnhancer enhancer : loggingEventEnhancers) { enhancer.enhanceLogEntry(builder, e); } } return builder.build(); }
static StringPayload fromPb(com.google.logging.v2.LogEntry entryPb) { return StringPayload.of(entryPb.getTextPayload()); } }