/** Example of asynchronously updating a sink. */ // [TARGET updateAsync(SinkInfo)] // [VARIABLE "my_sink_name"] // [VARIABLE "my_dataset"] public Sink updateSinkAsync(String sinkName, String datasetName) throws ExecutionException, InterruptedException { // [START updateSinkAsync] SinkInfo sinkInfo = SinkInfo.newBuilder(sinkName, DatasetDestination.of(datasetName)) .setVersionFormat(SinkInfo.VersionFormat.V2) .setFilter("severity>=ERROR") .build(); Future<Sink> future = logging.updateAsync(sinkInfo); // ... Sink sink = future.get(); // [END updateSinkAsync] return sink; }
@Test public void testToAndFromPb() { compareSinkInfo(BUCKET_SINK_INFO, SinkInfo.fromPb(BUCKET_SINK_INFO.toPb("project"))); compareSinkInfo(DATASET_SINK_INFO, SinkInfo.fromPb(DATASET_SINK_INFO.toPb("project"))); compareSinkInfo(TOPIC_SINK_INFO, SinkInfo.fromPb(TOPIC_SINK_INFO.toPb("project"))); SinkInfo sinkInfo = SinkInfo.of("name", BUCKET_DESTINATION); compareSinkInfo(sinkInfo, SinkInfo.fromPb(sinkInfo.toPb("project"))); sinkInfo = SinkInfo.of("name", DATASET_DESTINATION); compareSinkInfo(sinkInfo, SinkInfo.fromPb(sinkInfo.toPb("project"))); sinkInfo = SinkInfo.of("name", TOPIC_DESTINATION); compareSinkInfo(sinkInfo, SinkInfo.fromPb(sinkInfo.toPb("project"))); }
private void compareSinkInfo(SinkInfo expected, SinkInfo value) { assertEquals(expected, value); assertEquals(expected.getName(), value.getName()); assertEquals(expected.getDestination(), value.getDestination()); assertEquals(expected.getFilter(), value.getFilter()); assertEquals(expected.getVersionFormat(), value.getVersionFormat()); assertEquals(expected.hashCode(), value.hashCode()); assertEquals(expected.toString(), value.toString()); } }
@Test public void testCreateGetUpdateAndDeleteSink() { String name = formatForTest("test-create-get-update-sink"); SinkInfo sinkInfo = SinkInfo.newBuilder(name, DatasetDestination.of("dataset")) .setFilter("severity>=ERROR") .setVersionFormat(SinkInfo.VersionFormat.V2) .build(); Sink sink = logging().create(sinkInfo); assertEquals(name, sink.getName()); assertEquals(SinkInfo.VersionFormat.V2, sink.getVersionFormat()); assertEquals("severity>=ERROR", sink.getFilter()); DatasetDestination datasetDestination = sink.getDestination(); assertEquals(logging().getOptions().getProjectId(), datasetDestination.getProject()); assertEquals("dataset", datasetDestination.getDataset()); assertEquals(sink, logging().getSink(name)); sink = sink.toBuilder().setFilter("severity<=ERROR").build().update(); assertEquals(name, sink.getName()); assertEquals(SinkInfo.VersionFormat.V2, sink.getVersionFormat()); assertEquals("severity<=ERROR", sink.getFilter()); assertTrue(sink.delete()); assertFalse(sink.delete()); }
@Test public void testUpdateNonExistingSink() { String name = formatForTest("test-update-non-existing-sink"); SinkInfo sinkInfo = SinkInfo.newBuilder(name, DatasetDestination.of("dataset")) .setFilter("severity>=ERROR") .setVersionFormat(SinkInfo.VersionFormat.V2) .build(); assertNull(logging().getSink(name)); thrown.expect(LoggingException.class); thrown.expectMessage("NOT_FOUND"); logging().update(sinkInfo); }
@Test public void testListSinks() throws InterruptedException { String firstName = formatForTest("test-list-sinks-1"); String secondName = formatForTest("test-list-sinks-2"); Sink firstSink = logging().create(SinkInfo.of(firstName, DatasetDestination.of("dataset"))); Sink secondSink = logging().create(SinkInfo.of(secondName, DatasetDestination.of("dataset"))); Logging.ListOption[] options = {Logging.ListOption.pageSize(1)}; Page<Sink> sinkPage = logging().listSinks(options); Set<Sink> sinks = Sets.newHashSet(sinkPage.iterateAll()); while (!sinks.contains(firstSink) || !sinks.contains(secondSink)) { Thread.sleep(500); sinks = Sets.newHashSet(logging().listSinks(options).iterateAll()); } firstSink.delete(); secondSink.delete(); }
@Test public void testGetSink() { LogSink sinkPb = SINK_INFO.toPb(PROJECT); ApiFuture<LogSink> response = ApiFutures.immediateFuture(sinkPb); GetSinkRequest request = GetSinkRequest.newBuilder().setSinkName(SINK_NAME_PB).build(); EasyMock.expect(loggingRpcMock.get(request)).andReturn(response); EasyMock.replay(rpcFactoryMock, loggingRpcMock); logging = options.getService(); Sink sink = logging.getSink(SINK_NAME); assertEquals(new Sink(logging, new SinkInfo.BuilderImpl(SINK_INFO)), sink); }
@Test public void testUpdateSink() { LogSink sinkPb = SINK_INFO.toPb(PROJECT); ApiFuture<LogSink> response = ApiFutures.immediateFuture(sinkPb); UpdateSinkRequest request = UpdateSinkRequest.newBuilder().setSinkName(SINK_NAME_PB).setSink(sinkPb).build(); EasyMock.expect(loggingRpcMock.update(request)).andReturn(response); EasyMock.replay(rpcFactoryMock, loggingRpcMock); logging = options.getService(); Sink sink = logging.update(SINK_INFO); assertEquals(new Sink(logging, new SinkInfo.BuilderImpl(SINK_INFO)), sink); }
@Test public void testGetSinkAsync() throws ExecutionException, InterruptedException { LogSink sinkPb = SINK_INFO.toPb(PROJECT); ApiFuture<LogSink> response = ApiFutures.immediateFuture(sinkPb); GetSinkRequest request = GetSinkRequest.newBuilder().setSinkName(SINK_NAME_PB).build(); EasyMock.expect(loggingRpcMock.get(request)).andReturn(response); EasyMock.replay(rpcFactoryMock, loggingRpcMock); logging = options.getService(); Sink sink = logging.getSinkAsync(SINK_NAME).get(); assertEquals(new Sink(logging, new SinkInfo.BuilderImpl(SINK_INFO)), sink); }
@Test public void testUpdateSinkAsync() throws ExecutionException, InterruptedException { LogSink sinkPb = SINK_INFO.toPb(PROJECT); ApiFuture<LogSink> response = ApiFutures.immediateFuture(sinkPb); UpdateSinkRequest request = UpdateSinkRequest.newBuilder().setSinkName(SINK_NAME_PB).setSink(sinkPb).build(); EasyMock.expect(loggingRpcMock.update(request)).andReturn(response); EasyMock.replay(rpcFactoryMock, loggingRpcMock); logging = options.getService(); Sink sink = logging.updateAsync(SINK_INFO).get(); assertEquals(new Sink(logging, new SinkInfo.BuilderImpl(SINK_INFO)), sink); }
@Test public void testBuilder() { assertEquals(NAME, BUCKET_SINK_INFO.getName()); assertEquals(BUCKET_DESTINATION, BUCKET_SINK_INFO.getDestination()); assertEquals(FILTER, BUCKET_SINK_INFO.getFilter()); assertEquals(VERSION, BUCKET_SINK_INFO.getVersionFormat()); assertEquals(NAME, DATASET_SINK_INFO.getName()); assertEquals(DATASET_DESTINATION, DATASET_SINK_INFO.getDestination()); assertEquals(FILTER, DATASET_SINK_INFO.getFilter()); assertEquals(VERSION, DATASET_SINK_INFO.getVersionFormat()); assertEquals(NAME, TOPIC_SINK_INFO.getName()); assertEquals(TOPIC_DESTINATION, TOPIC_SINK_INFO.getDestination()); assertEquals(FILTER, TOPIC_SINK_INFO.getFilter()); assertEquals(VERSION, TOPIC_SINK_INFO.getVersionFormat()); }
public static void main(String... args) throws Exception { // Create a service object // Credentials are inferred from the environment try (Logging logging = LoggingOptions.getDefaultInstance().getService()) { // Create a sink to back log entries to a BigQuery dataset SinkInfo sinkInfo = SinkInfo.newBuilder("test-sink", DatasetDestination.of("test-dataset")) .setFilter("severity >= ERROR") .build(); logging.create(sinkInfo); // List sinks Page<Sink> sinks = logging.listSinks(); for (Sink sink : sinks.iterateAll()) { System.out.println(sink); } } } }
@Test public void testCreateSink() { LogSink sinkPb = SINK_INFO.toPb(PROJECT); ApiFuture<LogSink> response = ApiFutures.immediateFuture(sinkPb); CreateSinkRequest request = CreateSinkRequest.newBuilder().setParent(PROJECT_PB).setSink(sinkPb).build(); EasyMock.expect(loggingRpcMock.create(request)).andReturn(response); EasyMock.replay(rpcFactoryMock, loggingRpcMock); logging = options.getService(); Sink sink = logging.create(SINK_INFO); assertEquals(new Sink(logging, new SinkInfo.BuilderImpl(SINK_INFO)), sink); }
@Test public void testCreateSinkAsync() throws ExecutionException, InterruptedException { LogSink sinkPb = SINK_INFO.toPb(PROJECT); ApiFuture<LogSink> response = ApiFutures.immediateFuture(sinkPb); CreateSinkRequest request = CreateSinkRequest.newBuilder().setParent(PROJECT_PB).setSink(sinkPb).build(); EasyMock.expect(loggingRpcMock.create(request)).andReturn(response); EasyMock.replay(rpcFactoryMock, loggingRpcMock); logging = options.getService(); Sink sink = logging.createAsync(SINK_INFO).get(); assertEquals(new Sink(logging, new SinkInfo.BuilderImpl(SINK_INFO)), sink); }
/** Example of updating a sink. */ // [TARGET update(SinkInfo)] // [VARIABLE "my_sink_name"] // [VARIABLE "my_dataset"] public Sink updateSink(String sinkName, String datasetName) { // [START logging_update_sink] SinkInfo sinkInfo = SinkInfo.newBuilder(sinkName, DatasetDestination.of(datasetName)) .setVersionFormat(SinkInfo.VersionFormat.V2) .setFilter("severity>=ERROR") .build(); Sink sink = logging.update(sinkInfo); // [END logging_update_sink] return sink; }
@Override public ApiFuture<Sink> updateAsync(SinkInfo sink) { UpdateSinkRequest request = UpdateSinkRequest.newBuilder() .setSinkName(ProjectSinkName.of(getOptions().getProjectId(), sink.getName()).toString()) .setSink(sink.toPb(getOptions().getProjectId())) .build(); return transform(rpc.update(request), Sink.fromPbFunction(this)); }
/** * Example of creating a sink to export logs to a BigQuery dataset (in the {@link * LoggingOptions#getProjectId()} project). */ // [TARGET create(SinkInfo)] // [VARIABLE "my_sink_name"] // [VARIABLE "my_dataset"] public Sink createSink(String sinkName, String datasetName) { // [START logging_create_sink] SinkInfo sinkInfo = SinkInfo.of(sinkName, DatasetDestination.of(datasetName)); Sink sink = logging.create(sinkInfo); // [END logging_create_sink] return sink; }
/** * Example of asynchronously creating a sink to export logs to a BigQuery dataset (in the {@link * LoggingOptions#getProjectId()} project). */ // [TARGET createAsync(SinkInfo)] // [VARIABLE "my_sink_name"] // [VARIABLE "my_dataset"] public Sink createSinkAsync(String sinkName, String datasetName) throws ExecutionException, InterruptedException { // [START createSinkAsync] SinkInfo sinkInfo = SinkInfo.of(sinkName, DatasetDestination.of(datasetName)); Future<Sink> future = logging.createAsync(sinkInfo); // ... Sink sink = future.get(); // [END createSinkAsync] return sink; }
@Override SinkInfo parse(String... args) throws Exception { if (args.length >= 3) { if (args.length > 4) { throw new IllegalArgumentException("Too many arguments."); } String name = args[0]; Destination destination; switch (args[1]) { case "bucket": destination = BucketDestination.of(args[2]); break; case "dataset": destination = DatasetDestination.of(args[2]); break; case "topic": destination = TopicDestination.of(args[2]); break; default: throw new IllegalArgumentException("Second argument must be bucket|dataset|topic."); } SinkInfo.Builder builder = SinkInfo.newBuilder(name, destination); if (args.length == 4) { builder.setFilter(args[3]); } return builder.build(); } throw new IllegalArgumentException("Missing required sink name, destination or filter."); }