com.google.cloud.logging

Interface Logging

All Superinterfaces:

AutoCloseable, com.google.cloud.Service<LoggingOptions>

public interface Logging
extends AutoCloseable, com.google.cloud.Service<LoggingOptions>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Logging.EntryListOption Class for specifying options for listing log entries.
static class	Logging.ListOption Class for specifying options for listing sinks, monitored resources and monitored resource descriptors.
static class	Logging.SortingField Fields according to which log entries can be sorted.
static class	Logging.SortingOrder Sorting orders available when listing log entries.
static class	Logging.TailOption Class for specifying options for tailing log entries.
static class	Logging.WriteOption Class for specifying options for writing log entries.

Method Summary

Modifier and Type	Method and Description
Exclusion	create(Exclusion exclusion) Creates a new exclusion in a specified parent resource.
Metric	create(MetricInfo metric) Creates a new metric.
Sink	create(SinkInfo sink) Creates a new sink.
com.google.api.core.ApiFuture<Exclusion>	createAsync(Exclusion exclusion) Sends a request to create the exclusion.
com.google.api.core.ApiFuture<Metric>	createAsync(MetricInfo metric) Sends a request for creating a metric.
com.google.api.core.ApiFuture<Sink>	createAsync(SinkInfo sink) Sends a request for creating a sink.
boolean	deleteExclusion(String exclusion) Deletes the requested exclusion.
com.google.api.core.ApiFuture<Boolean>	deleteExclusionAsync(String exclusion) Sends a request to delete an exclusion.
boolean	deleteLog(String log) Deletes a log and all its log entries.
default boolean	deleteLog(String log, LogDestinationName destination) Deletes a log and all its log entries for given log destination (see 'logName' parameter in https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry).
com.google.api.core.ApiFuture<Boolean>	deleteLogAsync(String log) Sends a request for deleting a log and all its log entries.
default com.google.api.core.ApiFuture<Boolean>	deleteLogAsync(String log, LogDestinationName destination) Sends a request for deleting a log and all its log entries for given log destination (see 'logName' parameter in https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry).
boolean	deleteMetric(String metric) Deletes the requested metric.
com.google.api.core.ApiFuture<Boolean>	deleteMetricAsync(String metric) Sends a request for deleting a metric.
boolean	deleteSink(String sink) Deletes the requested sink.
com.google.api.core.ApiFuture<Boolean>	deleteSinkAsync(String sink) Sends a request for deleting a sink.
void	flush() Flushes any pending asynchronous logging writes.
Exclusion	getExclusion(String exclusion) Gets the description of an exclusion or null if not found.
com.google.api.core.ApiFuture<Exclusion>	getExclusionAsync(String exclusion) Sends a request to get the description of an exclusion .
Severity	getFlushSeverity()
Metric	getMetric(String metric) Returns the requested metric or null if not found.
com.google.api.core.ApiFuture<Metric>	getMetricAsync(String metric) Sends a request for getting a metric.
Sink	getSink(String sink) Returns the requested sink or null if not found.
com.google.api.core.ApiFuture<Sink>	getSinkAsync(String sink) Sends a request for getting a sink.
Synchronicity	getWriteSynchronicity() Retrieves current set synchronicity Synchronicity of logging writes.
com.google.api.gax.paging.Page<Exclusion>	listExclusions(Logging.ListOption... options) Lists the exclusion.
com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<Exclusion>>	listExclusionsAsync(Logging.ListOption... options) Sends a request for listing exclusions.
com.google.api.gax.paging.Page<LogEntry>	listLogEntries(Logging.EntryListOption... options) Lists log entries.
com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<LogEntry>>	listLogEntriesAsync(Logging.EntryListOption... options) Sends a request for listing log entries.
default com.google.api.gax.paging.Page<String>	listLogs(Logging.ListOption... options) Lists the log names.
default com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<String>>	listLogsAsync(Logging.ListOption... options) Sends a request for listing log names.
com.google.api.gax.paging.Page<Metric>	listMetrics(Logging.ListOption... options) Lists the metrics.
com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<Metric>>	listMetricsAsync(Logging.ListOption... options) Sends a request for listing metrics.
com.google.api.gax.paging.Page<com.google.cloud.MonitoredResourceDescriptor>	listMonitoredResourceDescriptors(Logging.ListOption... options) Lists the monitored resource descriptors used by Cloud Logging.
com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<com.google.cloud.MonitoredResourceDescriptor>>	listMonitoredResourceDescriptorsAsync(Logging.ListOption... options) Sends a request for listing monitored resource descriptors used by Cloud Logging.
com.google.api.gax.paging.Page<Sink>	listSinks(Logging.ListOption... options) Lists the sinks.
com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<Sink>>	listSinksAsync(Logging.ListOption... options) Sends a request for listing sinks.
default Iterable<LogEntry>	populateMetadata(Iterable<LogEntry> logEntries, com.google.cloud.MonitoredResource customResource, String... exclusionClassPaths) Populates metadata fields of the immutable collection of LogEntry items.
void	setFlushSeverity(Severity flushSeverity) Sets flush severity for asynchronous logging writes.
void	setWriteSynchronicity(Synchronicity synchronicity) Sets synchronicity Synchronicity of logging writes, defaults to asynchronous.
LogEntryServerStream	tailLogEntries(Logging.TailOption... options) Sends a request to stream fresh log entries.
Exclusion	update(Exclusion exclusion) Updates one or more properties of an existing exclusion.
Metric	update(MetricInfo metric) Updates a metric or creates one if it does not exist.
Sink	update(SinkInfo sink) Updates a sink or creates one if it does not exist.
com.google.api.core.ApiFuture<Exclusion>	updateAsync(Exclusion exclusion) Sends a request to change one or more properties of an existing exclusion.
com.google.api.core.ApiFuture<Metric>	updateAsync(MetricInfo metric) Sends a request for updating a metric (or creating it, if it does not exist).
com.google.api.core.ApiFuture<Sink>	updateAsync(SinkInfo sink) Sends a request for updating a sink (or creating it, if it does not exist).
void	write(Iterable<LogEntry> logEntries, Logging.WriteOption... options) Sends a request to log entries to Cloud Logging.

Methods inherited from interface java.lang.AutoCloseable

close

Methods inherited from interface com.google.cloud.Service

getOptions

Method Detail

setWriteSynchronicity

void setWriteSynchronicity(Synchronicity synchronicity)

Sets synchronicity Synchronicity of logging writes, defaults to asynchronous.

getWriteSynchronicity

Synchronicity getWriteSynchronicity()

Retrieves current set synchronicity Synchronicity of logging writes.

setFlushSeverity

void setFlushSeverity(Severity flushSeverity)

Sets flush severity for asynchronous logging writes. It is disabled by default, enabled when this method is called with not null value. Logs will be immediately written out for entries at or higher than flush severity.

Enabling this can cause the leaking and hanging threads, see BUG(2796) BUG(3880). However you can explicitly call flush().

TODO: Enable this by default once functionality to trigger rpc is available in generated code.

getFlushSeverity

Severity getFlushSeverity()

create

Sink create(SinkInfo sink)

Creates a new sink.

Example of creating a sink to export logs to a BigQuery dataset (in the ServiceOptions.getProjectId() project).

 {
   @code
   String sinkName = "my_sink_name";
   String datasetName = "my_dataset";
   SinkInfo sinkInfo = SinkInfo.of(sinkName, DatasetDestination.of(datasetName));
   Sink sink = logging.create(sinkInfo);
 }
 

Returns:

the created sink

Throws:

LoggingException - upon failure

create

Metric create(MetricInfo metric)

Creates a new metric.

Example of creating a metric for logs with severity higher or equal to ERROR.

 {
   @code
   String metricName = "my_metric_name";
   MetricInfo metricInfo = MetricInfo.of(metricName, "severity>=ERROR");
   Metric metric = logging.create(metricInfo);
 }
 

Returns:

the created metric

Throws:

LoggingException - upon failure

create

Exclusion create(Exclusion exclusion)

Creates a new exclusion in a specified parent resource. Only log entries belonging to that resource can be excluded. You can have up to 10 exclusions in a resource.

Example of creating the exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   Exclusion exclusion = Exclusion.of(exclusionName,
       "resource.type=gcs_bucket severity

Returns:

the created exclusion

Throws:

LoggingException - upon failure

createAsync

com.google.api.core.ApiFuture<Sink> createAsync(SinkInfo sink)

Sends a request for creating a sink. This method returns a ApiFuture object to consume the result. Future.get() returns the created sink.

Example of asynchronously creating a sink to export logs to a BigQuery dataset (in the ServiceOptions.getProjectId() project).

 {
   @code
   String sinkName = "my_sink_name";
   String datasetName = "my_dataset";
   SinkInfo sinkInfo = SinkInfo.of(sinkName, DatasetDestination.of(datasetName));
   ApiFuture future = logging.createAsync(sinkInfo);
   // ...
   Sink sink = future.get();
 }
 

createAsync

com.google.api.core.ApiFuture<Metric> createAsync(MetricInfo metric)

Sends a request for creating a metric. This method returns a ApiFuture object to consume the result. Future.get() returns the created metric.

Example of asynchronously creating a metric for logs with severity higher or equal to ERROR.

 {
   @code
   String metricName = "my_metric_name";
   MetricInfo metricInfo = MetricInfo.of(metricName, "severity>=ERROR");
   ApiFuture future = logging.createAsync(metricInfo);
   // ...
   Metric metric = future.get();
 }
 

createAsync

com.google.api.core.ApiFuture<Exclusion> createAsync(Exclusion exclusion)

Sends a request to create the exclusion. This method returns an ApiFuture object to consume the result. Future.get() returns the created exclusion.

Example of asynchronously creating the exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   Exclusion exclusion = Exclusion.of(exclusionName,
       "resource.type=gcs_bucket severity future = logging.createAsync(exclusion);
   // ...
   Exclusion exclusion = future.get();
 }
 

update

Sink update(SinkInfo sink)

Updates a sink or creates one if it does not exist.

Example of updating a sink.

 {
   @code
   String sinkName = "my_sink_name";
   String datasetName = "my_dataset";
   SinkInfo sinkInfo = SinkInfo.newBuilder(sinkName, DatasetDestination.of(datasetName))
       .setVersionFormat(SinkInfo.VersionFormat.V2).setFilter("severity>=ERROR").build();
   Sink sink = logging.update(sinkInfo);
 }
 

Returns:

the created sink

Throws:

LoggingException - upon failure

update

Metric update(MetricInfo metric)

Updates a metric or creates one if it does not exist.

Example of updating a metric.

 {
   @code
   String metricName = "my_metric_name";
   MetricInfo metricInfo = MetricInfo.newBuilder(metricName, "severity>=ERROR").setDescription("new description")
       .build();
   Metric metric = logging.update(metricInfo);
 }
 

Returns:

the created metric

Throws:

LoggingException - upon failure

update

Exclusion update(Exclusion exclusion)

Updates one or more properties of an existing exclusion.

Example of updating the exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   Exclusion exclusion = Exclusion
       .newBuilder(exclusionName, "resource.type=gcs_bucket severity

Returns:

the updated exclusion

Throws:

LoggingException - upon failure

updateAsync

com.google.api.core.ApiFuture<Sink> updateAsync(SinkInfo sink)

Sends a request for updating a sink (or creating it, if it does not exist). This method returns a ApiFuture object to consume the result. Future.get() returns the updated/created sink or null if not found.

Example of asynchronously updating a sink.

 {
   @code
   String sinkName = "my_sink_name";
   String datasetName = "my_dataset";
   SinkInfo sinkInfo = SinkInfo.newBuilder(sinkName, DatasetDestination.of(datasetName))
       .setVersionFormat(SinkInfo.VersionFormat.V2).setFilter("severity>=ERROR").build();
   ApiFuture future = logging.updateAsync(sinkInfo);
   // ...
   Sink sink = future.get();
 }
 

updateAsync

com.google.api.core.ApiFuture<Metric> updateAsync(MetricInfo metric)

Sends a request for updating a metric (or creating it, if it does not exist). This method returns a ApiFuture object to consume the result. Future.get() returns the updated/created metric or null if not found.

Example of asynchronously updating a metric.

 {
   @code
   String metricName = "my_metric_name";
   MetricInfo metricInfo = MetricInfo.newBuilder(metricName, "severity>=ERROR").setDescription("new description")
       .build();
   ApiFuture future = logging.updateAsync(metricInfo);
   // ...
   Metric metric = future.get();
 }
 

updateAsync

com.google.api.core.ApiFuture<Exclusion> updateAsync(Exclusion exclusion)

Sends a request to change one or more properties of an existing exclusion. This method returns an ApiFuture object to consume the result. Future.get() returns the updated exclusion or null if not found.

Example of asynchronous exclusion update:

 {
   @code
   String exclusionName = "my_exclusion_name";
   Exclusion exclusion = Exclusion
       .newBuilder(exclusionName, "resource.type=gcs_bucket severity future = logging.updateAsync(exclusion);
   // ...
   Exclusion exclusion = future.get();
 }
 

getSink

Sink getSink(String sink)

Returns the requested sink or null if not found.

Example of getting a sink.

 {
   @code
   String sinkName = "my_sink_name";
   Sink sink = logging.getSink(sinkName);
   if (sink == null) {
     // sink was not found
   }
 }
 

Throws:

LoggingException - upon failure

getSinkAsync

com.google.api.core.ApiFuture<Sink> getSinkAsync(String sink)

Sends a request for getting a sink. This method returns a ApiFuture object to consume the result. Future.get() returns the requested sink or null if not found.

Example of asynchronously getting a sink.

 {
   @code
   String sinkName = "my_sink_name";
   ApiFuture future = logging.getSinkAsync(sinkName);
   // ...
   Sink sink = future.get();
   if (sink == null) {
     // sink was not found
   }
 }
 

Throws:

LoggingException - upon failure

listSinks

com.google.api.gax.paging.Page<Sink> listSinks(Logging.ListOption... options)

Lists the sinks. This method returns a Page object that can be used to consume paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing sinks.

Example of listing sinks, specifying the page size.

 {
   @code
   Page sinks = logging.listSinks(ListOption.pageSize(100));
   Iterator sinkIterator = sinks.iterateAll().iterator();
   while (sinkIterator.hasNext()) {
     Sink sink = sinkIterator.next();
     // do something with the sink
   }
 }
 

Throws:

LoggingException - upon failure

listSinksAsync

com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<Sink>> listSinksAsync(Logging.ListOption... options)

Sends a request for listing sinks. This method returns a ApiFuture object to consume the result. Future.get() returns an AsyncPage object that can be used to asynchronously handle paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing sinks.

Example of asynchronously listing sinks, specifying the page size.

 ApiFuture<AsyncPage<Sink>> future = logging.listSinksAsync(ListOption.pageSize(100));
 // ...
 AsyncPage<Sink> sinks = future.get();
 Iterator<Sink> sinkIterator = sinks.iterateAll().iterator();
 while (sinkIterator.hasNext()) {
   Sink sink = sinkIterator.next();
   // do something with the sink
 }
 

deleteSink

boolean deleteSink(String sink)

Deletes the requested sink.

Example of deleting a sink.

 {
   @code
   String sinkName = "my_sink_name";
   boolean deleted = logging.deleteSink(sinkName);
   if (deleted) {
     // the sink was deleted
   } else {
     // the sink was not found
   }
 }
 

Returns:

true if the sink was deleted, false if it was not found

deleteSinkAsync

com.google.api.core.ApiFuture<Boolean> deleteSinkAsync(String sink)

Sends a request for deleting a sink. This method returns a ApiFuture object to consume the result. Future.get() returns true if the sink was deleted, false if it was not found.

Example of asynchronously deleting a sink.

 {
   @code
   String sinkName = "my_sink_name";
   ApiFuture future = logging.deleteSinkAsync(sinkName);
   // ...
   boolean deleted = future.get();
   if (deleted) {
     // the sink was deleted
   } else {
     // the sink was not found
   }
 }
 

listLogs

default com.google.api.gax.paging.Page<String> listLogs(Logging.ListOption... options)

Lists the log names. This method returns a Page object that can be used to consume paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing logs.

Example of listing log names, specifying the page size.

 {
   @code
   Page logNames = logging.listLogs(ListOption.pageSize(100));
   Iterator logIterator = logNames.iterateAll().iterator();
   while (logIterator.hasNext()) {
     String logName = logIterator.next();
     // do something with the log name
   }
 }
 

Throws:

LoggingException - upon failure

listLogsAsync

default com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<String>> listLogsAsync(Logging.ListOption... options)

Sends a request for listing log names. This method returns a ApiFuture object to consume the result. Future.get() returns an AsyncPage object that can be used to asynchronously handle paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing log names.

Example of asynchronously listing log names, specifying the page size.

 ApiFuture<AsyncPage<Log>> future = logging.listLogsAsync(ListOption.pageSize(100));
 // ...
 AsyncPage<Sink> logNames = future.get();
 Iterator<Sink> logIterator = logNames.iterateAll().iterator();
 while (logIterator.hasNext()) {
   String logName = logIterator.next();
   // do something with the log name
 }
 

deleteLog

boolean deleteLog(String log)

Deletes a log and all its log entries. The log will reappear if new entries are written to it.

Example of deleting a log.

 {
   @code
   String logName = "my_log_name";
   boolean deleted = logging.deleteLog(logName);
   if (deleted) {
     // the log was deleted
   } else {
     // the log was not found
   }
 }
 

Returns:

true if the log was deleted, false if it was not found

deleteLog

default boolean deleteLog(String log,
                          LogDestinationName destination)

Deletes a log and all its log entries for given log destination (see 'logName' parameter in https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry). The log will reappear if new entries are written to it.

Example of deleting a log by folder destination.

 {
   @code
   String logName = "my_log_name";
   String folder = "my_folder";
   boolean deleted = logging.deleteLog(logName, LogDestinationName.folder(folder));
   if (deleted) {
     // the log was deleted
   } else {
     // the log was not found
   }
 }
 

Returns:

true if the log was deleted, false if it was not found

deleteLogAsync

default com.google.api.core.ApiFuture<Boolean> deleteLogAsync(String log,
                                                              LogDestinationName destination)

Sends a request for deleting a log and all its log entries for given log destination (see 'logName' parameter in https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry). This method returns a ApiFuture object to consume the result. Future.get() returns true if the log was deleted, false if it was not found.

Example of asynchronously deleting a log by folder destination.

 {
   @code
   String logName = "my_log_name";
   String folder = "my_folder";
   ApiFuture future = logging.deleteLogAsync(logName, LogDestinationName.folder(folder));
   // ...
   boolean deleted = future.get();
   if (deleted) {
     // the log was deleted
   } else {
     // the log was not found
   }
 }
 

deleteLogAsync

com.google.api.core.ApiFuture<Boolean> deleteLogAsync(String log)

Sends a request for deleting a log and all its log entries. This method returns a ApiFuture object to consume the result. Future.get() returns true if the log was deleted, false if it was not found.

Example of asynchronously deleting a log.

 {
   @code
   String logName = "my_log_name";
   ApiFuture future = logging.deleteLogAsync(logName);
   // ...
   boolean deleted = future.get();
   if (deleted) {
     // the log was deleted
   } else {
     // the log was not found
   }
 }
 

listMonitoredResourceDescriptors

com.google.api.gax.paging.Page<com.google.cloud.MonitoredResourceDescriptor> listMonitoredResourceDescriptors(Logging.ListOption... options)

Lists the monitored resource descriptors used by Cloud Logging. This method returns a Page object that can be used to consume paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing resource descriptors.

Example of listing monitored resource descriptors, specifying the page size.

 {
   @code
   Page descriptors = logging
       .listMonitoredResourceDescriptors(ListOption.pageSize(100));
   Iterator descriptorIterator = descriptors.iterateAll().iterator();
   while (descriptorIterator.hasNext()) {
     MonitoredResourceDescriptor descriptor = descriptorIterator.next();
     // do something with the descriptor
   }
 }
 

Throws:

LoggingException - upon failure

listMonitoredResourceDescriptorsAsync

com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<com.google.cloud.MonitoredResourceDescriptor>> listMonitoredResourceDescriptorsAsync(Logging.ListOption... options)

Sends a request for listing monitored resource descriptors used by Cloud Logging. This method returns a ApiFuture object to consume the result. Future.get() returns an AsyncPage object that can be used to asynchronously handle paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing resource descriptors.

Example of asynchronously listing monitored resource descriptors, specifying the page size.

 ApiFuture<AsyncPage<MonitoredResourceDescriptor>> future = logging
     .listMonitoredResourceDescriptorsAsync(ListOption.pageSize(100));
 // ...
 AsyncPage<MonitoredResourceDescriptor> descriptors = future.get();
 Iterator<MonitoredResourceDescriptor> descriptorIterator = descriptors.iterateAll().iterator();
 while (descriptorIterator.hasNext()) {
   MonitoredResourceDescriptor descriptor = descriptorIterator.next();
   // do something with the descriptor
 }
 

getMetric

Metric getMetric(String metric)

Returns the requested metric or null if not found.

Example of getting a metric.

 {
   @code
   String metricName = "my_metric_name";
   Metric metric = logging.getMetric(metricName);
   if (metric == null) {
     // metric was not found
   }
 }
 

Throws:

LoggingException - upon failure

getMetricAsync

com.google.api.core.ApiFuture<Metric> getMetricAsync(String metric)

Sends a request for getting a metric. This method returns a ApiFuture object to consume the result. Future.get() returns the requested metric or null if not found.

Example of asynchronously getting a metric.

 {
   @code
   String metricName = "my_metric_name";
   ApiFuture future = logging.getMetricAsync(metricName);
   // ...
   Metric metric = future.get();
   if (metric == null) {
     // metric was not found
   }
 }
 

Throws:

LoggingException - upon failure

listMetrics

com.google.api.gax.paging.Page<Metric> listMetrics(Logging.ListOption... options)

Lists the metrics. This method returns a Page object that can be used to consume paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing metrics.

Example of listing metrics, specifying the page size.

 {
   @code
   Page metrics = logging.listMetrics(ListOption.pageSize(100));
   Iterator metricIterator = metrics.iterateAll().iterator();
   while (metricIterator.hasNext()) {
     Metric metric = metricIterator.next();
     // do something with the metric
   }
 }
 

Throws:

LoggingException - upon failure

listMetricsAsync

com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<Metric>> listMetricsAsync(Logging.ListOption... options)

Sends a request for listing metrics. This method returns a ApiFuture object to consume the result. Future.get() returns an AsyncPage object that can be used to asynchronously handle paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing metrics.

Example of asynchronously listing metrics, specifying the page size.

 ApiFuture<AsyncPage<Metric>> future = logging.listMetricsAsync(ListOption.pageSize(100));
 // ...
 AsyncPage<Metric> metrics = future.get();
 Iterator<Metric> metricIterator = metrics.iterateAll().iterator();
 while (metricIterator.hasNext()) {
   Metric metric = metricIterator.next();
   // do something with the metric
 }
 

deleteMetric

boolean deleteMetric(String metric)

Deletes the requested metric.

Example of deleting a metric.

 {
   @code
   String metricName = "my_metric_name";
   boolean deleted = logging.deleteMetric(metricName);
   if (deleted) {
     // the metric was deleted
   } else {
     // the metric was not found
   }
 }
 

Returns:

true if the metric was deleted, false if it was not found

deleteMetricAsync

com.google.api.core.ApiFuture<Boolean> deleteMetricAsync(String metric)

Sends a request for deleting a metric. This method returns a ApiFuture object to consume the result. Future.get() returns true if the metric was deleted, false if it was not found.

Example of asynchronously deleting a metric.

 {
   @code
   String metricName = "my_metric_name";
   ApiFuture future = logging.deleteMetricAsync(metricName);
   // ...
   boolean deleted = future.get();
   if (deleted) {
     // the metric was deleted
   } else {
     // the metric was not found
   }
 }
 

getExclusion

Exclusion getExclusion(String exclusion)

Gets the description of an exclusion or null if not found.

Example of getting the description of an exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   Exclusion exclusion = logging.getExclusion(exclusionName);
   if (exclusion == null) {
     // exclusion was not found
   }
 }
 

Throws:

LoggingException - upon failure

getExclusionAsync

com.google.api.core.ApiFuture<Exclusion> getExclusionAsync(String exclusion)

Sends a request to get the description of an exclusion . This method returns an ApiFuture object to consume the result. Future.get() returns the requested exclusion or null if not found.

Example of asynchronously getting the exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   ApiFuture future = logging.getExclusionAsync(exclusionName);
   // ...
   Exclusion exclusion = future.get();
   if (exclusion == null) {
     // exclusion was not found
   }
 }
 

Throws:

LoggingException - upon failure

deleteExclusion

boolean deleteExclusion(String exclusion)

Deletes the requested exclusion.

Example of deleting the exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   boolean deleted = logging.deleteExclusion(exclusionName);
   if (deleted) {
     // the exclusion was deleted
   } else {
     // the exclusion was not found
   }
 }
 

Returns:

true if the exclusion was deleted, false if it was not found

deleteExclusionAsync

com.google.api.core.ApiFuture<Boolean> deleteExclusionAsync(String exclusion)

Sends a request to delete an exclusion. This method returns an ApiFuture object to consume the result. Future.get() returns true if the exclusion was deleted, false if it was not found.

Example of asynchronously deleting the exclusion:

 {
   @code
   String exclusionName = "my_exclusion_name";
   ApiFuture future = logging.deleteExclusionAsync(metricName);
   // ...
   boolean deleted = future.get();
   if (deleted) {
     // the exclusion was deleted
   } else {
     // the exclusion was not found
   }
 }
 

listExclusions

com.google.api.gax.paging.Page<Exclusion> listExclusions(Logging.ListOption... options)

Lists the exclusion. This method returns a Page object that can be used to consume paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing exclusion.

Example of listing exclusions, specifying the page size:

 {
   @code
   Page exclusions = logging.listMetrics(ListOption.pageSize(100));
   Iterator exclusionIterator = exclusions.iterateAll().iterator();
   while (exclusionIterator.hasNext()) {
     Exclusion exclusion = exclusionIterator.next();
     // do something with the exclusion
   }
 }
 

Throws:

LoggingException - upon failure

listExclusionsAsync

com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<Exclusion>> listExclusionsAsync(Logging.ListOption... options)

Sends a request for listing exclusions. This method returns an ApiFuture object to consume the result. Future.get() returns an AsyncPage object that can be used to asynchronously handle paginated results. Use Logging.ListOption to specify the page size or the page token from which to start listing exclusions.

Example of asynchronously listing exclusions, specifying the page size:

 ApiFuture<AsyncPage<Exclusion>> future = logging.listExclusionsAsync(ListOption.pageSize(100));
 // ...
 AsyncPage<Exclusion> exclusions = future.get();
 Iterator<Exclusion> exclusionIterator = exclusions.iterateAll().iterator();
 while (exclusionIterator.hasNext()) {
   Exclusion exclusion = exclusionIterator.next();
   // do something with the exclusion
 }
 

flush

void flush()

Flushes any pending asynchronous logging writes. Logs are automatically flushed based on time and message count that be configured via BatchingSettings, Logs are also flushed if enabled, at or above flush severity, see setFlushSeverity(com.google.cloud.logging.Severity). Logging frameworks require support for an explicit flush. See usage in the java.util.logging handlerLoggingHandler.

write

void write(Iterable<LogEntry> logEntries,
           Logging.WriteOption... options)

Sends a request to log entries to Cloud Logging. Use Logging.WriteOption.logName(String) to provide a log name for those entries that do not specify one. Use Logging.WriteOption.resource(MonitoredResource) to provide a monitored resource for those entries that do not specify one. Use Logging.WriteOption.labels(Map) to provide some labels to be added to every entry in logEntries.

Example of writing log entries and providing a default log name and monitored resource.

 String logName = "my_log_name";
 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()));
 

listLogEntries

com.google.api.gax.paging.Page<LogEntry> listLogEntries(Logging.EntryListOption... options)

Lists log entries. This method returns a Page object that can be used to consume paginated results. Use Logging.EntryListOption.pageSize(int) to specify the page size. Use Logging.EntryListOption.pageToken(String) to specify the page token from which to start listing entries. Use EntryListOption#sortOrder(SortingField, SortingOrder) to sort log entries according to your preferred order (default is most-recent last). Use Logging.EntryListOption.filter(String) to filter listed log entries.

Example of listing log entries for a specific log.

 {
   @code
   String filter = "logName=projects/my_project_id/logs/my_log_name";
   Page entries = logging.listLogEntries(EntryListOption.filter(filter));
   Iterator entryIterator = entries.iterateAll().iterator();
   while (entryIterator.hasNext()) {
     LogEntry entry = entryIterator.next();
     // do something with the entry
   }
 }
 

Throws:

LoggingException - upon failure

listLogEntriesAsync

com.google.api.core.ApiFuture<com.google.api.gax.paging.AsyncPage<LogEntry>> listLogEntriesAsync(Logging.EntryListOption... options)

Sends a request for listing log entries. This method returns a ApiFuture object to consume the result. Future.get() returns an AsyncPage object that can be used to asynchronously handle paginated results. Use Logging.EntryListOption.pageSize(int) to specify the page size. Use Logging.EntryListOption.pageToken(String) to specify the page token from which to start listing entries. Use EntryListOption#sortOrder(SortingField, SortingOrder) to sort log entries according to your preferred order (default is most-recent last). Use Logging.EntryListOption.filter(String) to filter listed log entries.

Example of asynchronously listing log entries for a specific log.

 String filter = "logName=projects/my_project_id/logs/my_log_name";
 ApiFuture<AsyncPage<LogEntry>> future = logging.listLogEntriesAsync(EntryListOption.filter(filter));
 // ...
 AsyncPage<LogEntry> entries = future.get();
 Iterator<LogEntry> entryIterator = entries.iterateAll().iterator();
 while (entryIterator.hasNext()) {
   LogEntry entry = entryIterator.next();
   // do something with the entry
 }
 

Throws:

LoggingException - upon failure

tailLogEntries

@BetaApi(value="The surface for the tail streaming is not stable yet and may change in the future.")
LogEntryServerStream tailLogEntries(Logging.TailOption... options)

Sends a request to stream fresh log entries. The method returns a LogEntryServerStream object to iterate through the returned stream of the log entries. Use EntryListOption#bufferWindow(String)} to specify amount of time to buffer log entries at the server before being returned. entries. Use Logging.TailOption.filter(String) to filter tailed log entries.

Example of streaming log entries for a specific project.

 
 LogEntryServerStream stream = logging.tailLogEntries(TailOption.project("my_project_id"));
 Iterator it = stream.iterator();
 while (it.hasNext()) {
   // do something with entry
   // call stream.cancel(); to stop streaming
 }
 }
 

populateMetadata

default Iterable<LogEntry> populateMetadata(Iterable<LogEntry> logEntries,
                                            com.google.cloud.MonitoredResource customResource,
                                            String... exclusionClassPaths)

Populates metadata fields of the immutable collection of LogEntry items. Only empty fields are populated. The SourceLocation is populated only for items with the severity set to Severity.DEBUG. The information about HttpRequest, trace and span Id is retrieved using ContextHandler.

Parameters:

logEntries - an immutable collection of LogEntry items.

customResource - a customized instance of the MonitoredResource. If this parameter is null then the new instance will be generated using MonitoredResourceUtil.getResource(String, String).

exclusionClassPaths - a list of exclussion class path prefixes. If left empty then SourceLocation instance is built based on the caller's stack trace information. Otherwise, the information from the first StackTraceElement along the call stack which class name does not start with any not null exclusion class paths is used.

Returns:

A collection of LogEntry items composed from the logEntries parameter with populated metadata fields.