diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/build.gradle b/instrumentation/aws-java-sdk-kinesis-1.11.106/build.gradle new file mode 100644 index 0000000000..c3aa9ff565 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/build.gradle @@ -0,0 +1,12 @@ +dependencies { + implementation(project(":agent-bridge")) + implementation("com.amazonaws:aws-java-sdk-kinesis:1.11.106") +} + +jar { + manifest { attributes 'Implementation-Title': 'com.newrelic.instrumentation.aws-java-sdk-kinesis-1.11.106' } +} + +verifyInstrumentation { + passesOnly 'com.amazonaws:aws-java-sdk-kinesis:[1.11.106,)' +} \ No newline at end of file diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/KinesisUtil.java b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/KinesisUtil.java new file mode 100644 index 0000000000..88e4a8d97f --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/KinesisUtil.java @@ -0,0 +1,63 @@ +package com.agent.instrumentation.awsjavasdk2.services.kinesis; + +import com.amazonaws.AmazonWebServiceRequest; +import com.amazonaws.handlers.AsyncHandler_Instrumentation; +import com.newrelic.agent.bridge.AgentBridge; +import com.newrelic.api.agent.CloudParameters; +import com.newrelic.api.agent.NewRelic; +import com.newrelic.api.agent.Token; +import com.newrelic.api.agent.TracedMethod; + +import java.util.Map; + +public class KinesisUtil { + + public static final String PLATFORM = "aws_kinesis_data_streams"; + public static final String TRACE_CATEGORY = "Kinesis"; + + public static final Map requestTokenMap = AgentBridge.collectionFactory.createConcurrentWeakKeyedMap(); + private KinesisUtil() {} + + public static void setTokenForRequest(AmazonWebServiceRequest request) { + if (AgentBridge.getAgent().getTransaction(false) != null) { + if (request != null) { + Token token = NewRelic.getAgent().getTransaction().getToken(); + requestTokenMap.put(request, token); + } + } + } + + public static void setTraceInformation(String kinesisOperation, AmazonWebServiceRequest request) { + Token token = KinesisUtil.getToken(request); + if (token != null) { + token.linkAndExpire(); + } + KinesisUtil.cleanToken(request); + TracedMethod tracedMethod = NewRelic.getAgent().getTransaction().getTracedMethod(); + KinesisUtil.setTraceDetails(kinesisOperation, tracedMethod); + } + + public static Token getToken(AmazonWebServiceRequest request) { + if (request != null) { + return requestTokenMap.get(request); + } + return null; + } + + public static void cleanToken(AmazonWebServiceRequest request) { + if (request != null) { + requestTokenMap.remove(request); + } + } + + public static void setTraceDetails(String kinesisOperation, TracedMethod tracedMethod) { + tracedMethod.setMetricName(TRACE_CATEGORY, kinesisOperation); + tracedMethod.reportAsExternal(createCloudParams()); + } + + public static CloudParameters createCloudParams() { + // Todo: add arn to cloud parameters + return CloudParameters.provider(PLATFORM).build(); + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/handlers/AsyncHandler_Instrumentation.java b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/handlers/AsyncHandler_Instrumentation.java new file mode 100644 index 0000000000..6a5e814917 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/handlers/AsyncHandler_Instrumentation.java @@ -0,0 +1,41 @@ +/* + * + * * Copyright 2020 New Relic Corporation. All rights reserved. + * * SPDX-License-Identifier: Apache-2.0 + * + */ + +package com.amazonaws.handlers; + +import com.amazonaws.AmazonWebServiceRequest; +import com.newrelic.api.agent.Token; +import com.newrelic.api.agent.Trace; +import com.newrelic.api.agent.weaver.MatchType; +import com.newrelic.api.agent.weaver.NewField; +import com.newrelic.api.agent.weaver.Weave; +import com.newrelic.api.agent.weaver.Weaver; + +@Weave(originalName ="com.amazonaws.handlers.AsyncHandler", type = MatchType.Interface) +public class AsyncHandler_Instrumentation { + + @NewField + public Token token; + + @Trace(async = true) + public void onError(Exception exception) { + if (token != null) { + token.linkAndExpire(); + token = null; + } + Weaver.callOriginal(); + } + + @Trace(async = true) + public void onSuccess(REQUEST request, RESULT result) { + if (token != null) { + token.linkAndExpire(); + token = null; + } + Weaver.callOriginal(); + } +} \ No newline at end of file diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/services/kinesis/AmazonKinesisAsyncClient_Instrumentation.java b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/services/kinesis/AmazonKinesisAsyncClient_Instrumentation.java new file mode 100644 index 0000000000..eee81f6fb1 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/services/kinesis/AmazonKinesisAsyncClient_Instrumentation.java @@ -0,0 +1,194 @@ +package com.amazonaws.services.kinesis; + +import com.agent.instrumentation.awsjavasdk2.services.kinesis.KinesisUtil; +import com.amazonaws.AmazonWebServiceRequest; +import com.amazonaws.handlers.AsyncHandler_Instrumentation; +import com.amazonaws.services.kinesis.model.AddTagsToStreamRequest; +import com.amazonaws.services.kinesis.model.AddTagsToStreamResult; +import com.amazonaws.services.kinesis.model.CreateStreamRequest; +import com.amazonaws.services.kinesis.model.CreateStreamResult; +import com.amazonaws.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import com.amazonaws.services.kinesis.model.DecreaseStreamRetentionPeriodResult; +import com.amazonaws.services.kinesis.model.DeleteStreamRequest; +import com.amazonaws.services.kinesis.model.DeleteStreamResult; +import com.amazonaws.services.kinesis.model.DescribeLimitsRequest; +import com.amazonaws.services.kinesis.model.DescribeLimitsResult; +import com.amazonaws.services.kinesis.model.DescribeStreamRequest; +import com.amazonaws.services.kinesis.model.DescribeStreamResult; +import com.amazonaws.services.kinesis.model.DisableEnhancedMonitoringRequest; +import com.amazonaws.services.kinesis.model.DisableEnhancedMonitoringResult; +import com.amazonaws.services.kinesis.model.EnableEnhancedMonitoringRequest; +import com.amazonaws.services.kinesis.model.EnableEnhancedMonitoringResult; +import com.amazonaws.services.kinesis.model.GetRecordsRequest; +import com.amazonaws.services.kinesis.model.GetRecordsResult; +import com.amazonaws.services.kinesis.model.GetShardIteratorRequest; +import com.amazonaws.services.kinesis.model.GetShardIteratorResult; +import com.amazonaws.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import com.amazonaws.services.kinesis.model.IncreaseStreamRetentionPeriodResult; +import com.amazonaws.services.kinesis.model.ListStreamsRequest; +import com.amazonaws.services.kinesis.model.ListStreamsResult; +import com.amazonaws.services.kinesis.model.ListTagsForStreamRequest; +import com.amazonaws.services.kinesis.model.ListTagsForStreamResult; +import com.amazonaws.services.kinesis.model.MergeShardsRequest; +import com.amazonaws.services.kinesis.model.MergeShardsResult; +import com.amazonaws.services.kinesis.model.PutRecordRequest; +import com.amazonaws.services.kinesis.model.PutRecordResult; +import com.amazonaws.services.kinesis.model.PutRecordsRequest; +import com.amazonaws.services.kinesis.model.PutRecordsResult; +import com.amazonaws.services.kinesis.model.RemoveTagsFromStreamRequest; +import com.amazonaws.services.kinesis.model.RemoveTagsFromStreamResult; +import com.amazonaws.services.kinesis.model.SplitShardRequest; +import com.amazonaws.services.kinesis.model.SplitShardResult; +import com.amazonaws.services.kinesis.model.UpdateShardCountRequest; +import com.amazonaws.services.kinesis.model.UpdateShardCountResult; +import com.newrelic.agent.bridge.AgentBridge; +import com.newrelic.api.agent.NewRelic; +import com.newrelic.api.agent.Trace; +import com.newrelic.api.agent.weaver.MatchType; +import com.newrelic.api.agent.weaver.Weave; +import com.newrelic.api.agent.weaver.Weaver; + +import java.util.concurrent.Future; + +@Weave(originalName ="com.amazonaws.services.kinesis.AmazonKinesisAsyncClient", type = MatchType.ExactClass) +public class AmazonKinesisAsyncClient_Instrumentation { + + @Trace + public Future addTagsToStreamAsync(AddTagsToStreamRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future createStreamAsync(CreateStreamRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future decreaseStreamRetentionPeriodAsync( + DecreaseStreamRetentionPeriodRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future deleteStreamAsync(DeleteStreamRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future describeLimitsAsync(DescribeLimitsRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future describeStreamAsync(DescribeStreamRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future disableEnhancedMonitoringAsync(DisableEnhancedMonitoringRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future enableEnhancedMonitoringAsync(EnableEnhancedMonitoringRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future getRecordsAsync(GetRecordsRequest request, AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future getShardIteratorAsync(GetShardIteratorRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future increaseStreamRetentionPeriodAsync( + IncreaseStreamRetentionPeriodRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future listStreamsAsync(ListStreamsRequest request, AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future listTagsForStreamAsync(ListTagsForStreamRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future mergeShardsAsync(MergeShardsRequest request, AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future putRecordAsync(PutRecordRequest request, AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future putRecordsAsync(PutRecordsRequest request, AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future removeTagsFromStreamAsync(RemoveTagsFromStreamRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future splitShardAsync(SplitShardRequest request, AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + @Trace + public Future updateShardCountAsync(UpdateShardCountRequest request, + AsyncHandler_Instrumentation asyncHandler) { + setToken(asyncHandler, request); + return Weaver.callOriginal(); + } + + private void setToken(AsyncHandler_Instrumentation asyncHandler, AmazonWebServiceRequest request) { + if (AgentBridge.getAgent().getTransaction(false) != null) { + if (asyncHandler != null) { + asyncHandler.token = NewRelic.getAgent().getTransaction().getToken(); + } + KinesisUtil.setTokenForRequest(request); + } + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/services/kinesis/AmazonKinesisClient_Instrumentation.java b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/services/kinesis/AmazonKinesisClient_Instrumentation.java new file mode 100644 index 0000000000..cf70acb0d3 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/main/java/com/amazonaws/services/kinesis/AmazonKinesisClient_Instrumentation.java @@ -0,0 +1,166 @@ +package com.amazonaws.services.kinesis; + +import com.agent.instrumentation.awsjavasdk2.services.kinesis.KinesisUtil; +import com.amazonaws.services.kinesis.model.AddTagsToStreamRequest; +import com.amazonaws.services.kinesis.model.AddTagsToStreamResult; +import com.amazonaws.services.kinesis.model.CreateStreamRequest; +import com.amazonaws.services.kinesis.model.CreateStreamResult; +import com.amazonaws.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import com.amazonaws.services.kinesis.model.DecreaseStreamRetentionPeriodResult; +import com.amazonaws.services.kinesis.model.DeleteStreamRequest; +import com.amazonaws.services.kinesis.model.DeleteStreamResult; +import com.amazonaws.services.kinesis.model.DescribeLimitsRequest; +import com.amazonaws.services.kinesis.model.DescribeLimitsResult; +import com.amazonaws.services.kinesis.model.DescribeStreamRequest; +import com.amazonaws.services.kinesis.model.DescribeStreamResult; +import com.amazonaws.services.kinesis.model.DisableEnhancedMonitoringRequest; +import com.amazonaws.services.kinesis.model.DisableEnhancedMonitoringResult; +import com.amazonaws.services.kinesis.model.EnableEnhancedMonitoringRequest; +import com.amazonaws.services.kinesis.model.EnableEnhancedMonitoringResult; +import com.amazonaws.services.kinesis.model.GetRecordsRequest; +import com.amazonaws.services.kinesis.model.GetRecordsResult; +import com.amazonaws.services.kinesis.model.GetShardIteratorRequest; +import com.amazonaws.services.kinesis.model.GetShardIteratorResult; +import com.amazonaws.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import com.amazonaws.services.kinesis.model.IncreaseStreamRetentionPeriodResult; +import com.amazonaws.services.kinesis.model.ListStreamsRequest; +import com.amazonaws.services.kinesis.model.ListStreamsResult; +import com.amazonaws.services.kinesis.model.ListTagsForStreamRequest; +import com.amazonaws.services.kinesis.model.ListTagsForStreamResult; +import com.amazonaws.services.kinesis.model.MergeShardsRequest; +import com.amazonaws.services.kinesis.model.MergeShardsResult; +import com.amazonaws.services.kinesis.model.PutRecordRequest; +import com.amazonaws.services.kinesis.model.PutRecordResult; +import com.amazonaws.services.kinesis.model.PutRecordsRequest; +import com.amazonaws.services.kinesis.model.PutRecordsResult; +import com.amazonaws.services.kinesis.model.RemoveTagsFromStreamRequest; +import com.amazonaws.services.kinesis.model.RemoveTagsFromStreamResult; +import com.amazonaws.services.kinesis.model.SplitShardRequest; +import com.amazonaws.services.kinesis.model.SplitShardResult; +import com.amazonaws.services.kinesis.model.UpdateShardCountRequest; +import com.amazonaws.services.kinesis.model.UpdateShardCountResult; +import com.newrelic.api.agent.NewRelic; +import com.newrelic.api.agent.Token; +import com.newrelic.api.agent.Trace; +import com.newrelic.api.agent.weaver.MatchType; +import com.newrelic.api.agent.weaver.Weave; +import com.newrelic.api.agent.weaver.Weaver; + +@Weave(originalName = "com.amazonaws.services.kinesis.AmazonKinesisClient", type = MatchType.ExactClass) +public class AmazonKinesisClient_Instrumentation { + + @Trace(async = true, leaf = true) + final AddTagsToStreamResult executeAddTagsToStream(AddTagsToStreamRequest request) { + KinesisUtil.setTraceInformation("addTagsToStream", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final CreateStreamResult executeCreateStream(CreateStreamRequest request) { + KinesisUtil.setTraceInformation("createStream", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final DecreaseStreamRetentionPeriodResult executeDecreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest request) { + KinesisUtil.setTraceInformation("decreaseStreamRetentionPeriod", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final DeleteStreamResult executeDeleteStream(DeleteStreamRequest request) { + KinesisUtil.setTraceInformation("deleteStream", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final DescribeLimitsResult executeDescribeLimits(DescribeLimitsRequest request) { + KinesisUtil.setTraceInformation("describeLimits", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final DescribeStreamResult executeDescribeStream(DescribeStreamRequest request) { + KinesisUtil.setTraceInformation("describeStream", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final DisableEnhancedMonitoringResult executeDisableEnhancedMonitoring(DisableEnhancedMonitoringRequest request) { + KinesisUtil.setTraceInformation("disableEnhancedMonitoring", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final EnableEnhancedMonitoringResult executeEnableEnhancedMonitoring(EnableEnhancedMonitoringRequest request) { + KinesisUtil.setTraceInformation("enableEnhancedMonitoring", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final GetRecordsResult executeGetRecords(GetRecordsRequest request) { + KinesisUtil.setTraceInformation("getRecords", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final GetShardIteratorResult executeGetShardIterator(GetShardIteratorRequest request) { + KinesisUtil.setTraceInformation("getShardIterator", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final IncreaseStreamRetentionPeriodResult executeIncreaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest request) { + KinesisUtil.setTraceInformation("increaseStreamRetentionPeriod", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final ListStreamsResult executeListStreams(ListStreamsRequest request) { + KinesisUtil.setTraceInformation("listStreams", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final ListTagsForStreamResult executeListTagsForStream(ListTagsForStreamRequest request) { + KinesisUtil.setTraceInformation("listTagsForStream", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final MergeShardsResult executeMergeShards(MergeShardsRequest request) { + KinesisUtil.setTraceInformation("mergeShards", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final PutRecordResult executePutRecord(PutRecordRequest request) { + KinesisUtil.setTraceInformation("putRecord", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final PutRecordsResult executePutRecords(PutRecordsRequest request) { + KinesisUtil.setTraceInformation("putRecords", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final RemoveTagsFromStreamResult executeRemoveTagsFromStream(RemoveTagsFromStreamRequest request) { + KinesisUtil.setTraceInformation("removeTagsFromStream", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final SplitShardResult executeSplitShard(SplitShardRequest request) { + KinesisUtil.setTraceInformation("splitShard", request); + return Weaver.callOriginal(); + } + + @Trace(async = true, leaf = true) + final UpdateShardCountResult executeUpdateShardCount(UpdateShardCountRequest request) { + KinesisUtil.setTraceInformation("updateShardCount", request); + return Weaver.callOriginal(); + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/src/test/java/com/amazonaws/services/kinesis/AmazonKinesisAPITest.java b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/test/java/com/amazonaws/services/kinesis/AmazonKinesisAPITest.java new file mode 100644 index 0000000000..f564ff645d --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/test/java/com/amazonaws/services/kinesis/AmazonKinesisAPITest.java @@ -0,0 +1,300 @@ +package com.amazonaws.services.kinesis; + +import com.amazonaws.AmazonWebServiceRequest; +import com.amazonaws.auth.AWSCredentials; +import com.amazonaws.auth.AWSCredentialsProvider; +import com.amazonaws.client.builder.AwsClientBuilder; +import com.amazonaws.handlers.AsyncHandler; +import com.amazonaws.services.kinesis.model.AddTagsToStreamRequest; +import com.amazonaws.services.kinesis.model.CreateStreamRequest; +import com.amazonaws.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import com.amazonaws.services.kinesis.model.DeleteStreamRequest; +import com.amazonaws.services.kinesis.model.DescribeLimitsRequest; +import com.amazonaws.services.kinesis.model.DescribeStreamRequest; +import com.amazonaws.services.kinesis.model.DisableEnhancedMonitoringRequest; +import com.amazonaws.services.kinesis.model.EnableEnhancedMonitoringRequest; +import com.amazonaws.services.kinesis.model.GetRecordsRequest; +import com.amazonaws.services.kinesis.model.GetShardIteratorRequest; +import com.amazonaws.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import com.amazonaws.services.kinesis.model.ListStreamsRequest; +import com.amazonaws.services.kinesis.model.ListTagsForStreamRequest; +import com.amazonaws.services.kinesis.model.MergeShardsRequest; +import com.amazonaws.services.kinesis.model.PutRecordRequest; +import com.amazonaws.services.kinesis.model.PutRecordsRequest; +import com.amazonaws.services.kinesis.model.RemoveTagsFromStreamRequest; +import com.amazonaws.services.kinesis.model.SplitShardRequest; +import com.amazonaws.services.kinesis.model.UpdateShardCountRequest; +import com.newrelic.agent.introspec.InstrumentationTestConfig; +import com.newrelic.agent.introspec.InstrumentationTestRunner; +import com.newrelic.agent.introspec.Introspector; +import com.newrelic.agent.introspec.SpanEvent; +import com.newrelic.agent.introspec.TraceSegment; +import com.newrelic.agent.introspec.TransactionTrace; +import com.newrelic.agent.introspec.internal.HttpServerRule; +import com.newrelic.api.agent.Trace; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.net.URISyntaxException; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.Future; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@RunWith(InstrumentationTestRunner.class) +@InstrumentationTestConfig(includePrefixes = {"com.amazonaws"}, configName = "dt_enabled.yml") +public class AmazonKinesisAPITest { + + @Rule + public HttpServerRule server = new HttpServerRule(); + private AmazonKinesis kinesisClient; + private AmazonKinesisAsync kinesisAsyncClient; + + @Before + public void setup() throws URISyntaxException { + String serverUriStr = server.getEndPoint().toString(); + AwsClientBuilder.EndpointConfiguration endpoint = new AwsClientBuilder.EndpointConfiguration(serverUriStr, "us-east-1"); + kinesisClient = AmazonKinesisClientBuilder.standard() + .withCredentials(new CredProvider()) + .withEndpointConfiguration(endpoint) + .build(); + kinesisAsyncClient = AmazonKinesisAsyncClientBuilder.standard() + .withCredentials(new CredProvider()) + .withEndpointConfiguration(endpoint) + .build(); + } + + // HttpServerRule is flaky so only 1 test is run + + @Test + public void testAddTagsToStream() { + txn(() -> kinesisClient.addTagsToStream(new AddTagsToStreamRequest())); + txnAsync(() -> kinesisAsyncClient.addTagsToStreamAsync(new AddTagsToStreamRequest())); + assertKinesisTrace("addTagsToStream", false); + } + +// @Test +// public void testCreateStream() { +// txn(() -> kinesisClient.createStream(new CreateStreamRequest())); +// txnAsync(() -> kinesisAsyncClient.createStreamAsync(new CreateStreamRequest())); +// assertKinesisTrace("createStream", false); +// } +// +// @Test +// public void testDecreaseStreamRetentionPeriod() { +// txn(() -> kinesisClient.decreaseStreamRetentionPeriod(new DecreaseStreamRetentionPeriodRequest())); +// txnAsync(() -> kinesisAsyncClient.decreaseStreamRetentionPeriodAsync(new DecreaseStreamRetentionPeriodRequest())); +// assertKinesisTrace("decreaseStreamRetentionPeriod", false); +// } +// +// @Test +// public void testDeleteStream() { +// txn(() -> kinesisClient.deleteStream(new DeleteStreamRequest())); +// txnAsync(() -> kinesisAsyncClient.deleteStreamAsync(new DeleteStreamRequest())); +// assertKinesisTrace("deleteStream", false); +// } +// +// @Test +// public void testDescribeLimits() { +// txn(() -> kinesisClient.describeLimits(new DescribeLimitsRequest())); +// txnAsync(() -> kinesisAsyncClient.describeLimitsAsync(new DescribeLimitsRequest())); +// assertKinesisTrace("describeLimits", false); +// } +// +// @Test +// public void testDescribeStream() { +// txn(() -> kinesisClient.describeStream(new DescribeStreamRequest())); +// txnAsync(() -> kinesisAsyncClient.describeStreamAsync(new DescribeStreamRequest())); +// assertKinesisTrace("describeStream", false); +// } +// +// @Test +// public void testDisableEnhancedMonitoring() { +// txn(() -> kinesisClient.disableEnhancedMonitoring(new DisableEnhancedMonitoringRequest())); +// txnAsync(() -> kinesisAsyncClient.disableEnhancedMonitoringAsync(new DisableEnhancedMonitoringRequest())); +// assertKinesisTrace("disableEnhancedMonitoring", false); +// } +// +// @Test +// public void testEnableEnhancedMonitoring() { +// txn(() -> kinesisClient.enableEnhancedMonitoring(new EnableEnhancedMonitoringRequest())); +// txnAsync(() -> kinesisAsyncClient.enableEnhancedMonitoringAsync(new EnableEnhancedMonitoringRequest())); +// assertKinesisTrace("enableEnhancedMonitoring", false); +// } +// +// @Test +// public void testGetRecords() { +// txn(() -> kinesisClient.getRecords(new GetRecordsRequest())); +// txnAsync(() -> kinesisAsyncClient.getRecordsAsync(new GetRecordsRequest())); +// assertKinesisTrace("getRecords", false); +// } +// +// @Test +// public void testGetShardIterator() { +// txn(() -> kinesisClient.getShardIterator(new GetShardIteratorRequest())); +// txnAsync(() -> kinesisAsyncClient.getShardIteratorAsync(new GetShardIteratorRequest())); +// assertKinesisTrace("getShardIterator", false); +// } +// +// @Test +// public void testIncreaseStreamRetentionPeriod() { +// txn(() -> kinesisClient.increaseStreamRetentionPeriod(new IncreaseStreamRetentionPeriodRequest())); +// txnAsync(() -> kinesisAsyncClient.increaseStreamRetentionPeriodAsync(new IncreaseStreamRetentionPeriodRequest())); +// assertKinesisTrace("increaseStreamRetentionPeriod", false); +// } +// +// @Test +// public void testListStreams() { +// txn(() -> kinesisClient.listStreams(new ListStreamsRequest())); +// txnAsync(() -> kinesisAsyncClient.listStreamsAsync(new ListStreamsRequest())); +// assertKinesisTrace("listStreams", false); +// } +// +// @Test +// public void testListTagsForStream() { +// txn(() -> kinesisClient.listTagsForStream(new ListTagsForStreamRequest())); +// txnAsync(() -> kinesisAsyncClient.listTagsForStreamAsync(new ListTagsForStreamRequest())); +// assertKinesisTrace("listTagsForStream", false); +// } +// +// @Test +// public void testMergeShards() { +// txn(() -> kinesisClient.mergeShards(new MergeShardsRequest())); +// txnAsync(() -> kinesisAsyncClient.mergeShardsAsync(new MergeShardsRequest())); +// assertKinesisTrace("mergeShards", false); +// } +// +// @Test +// public void testPutRecord() { +// txn(() -> kinesisClient.putRecord(new PutRecordRequest())); +// txnAsync(() -> kinesisAsyncClient.putRecordAsync(new PutRecordRequest())); +// assertKinesisTrace("putRecord", false); +// } +// +// @Test +// public void testPutRecords() { +// txn(() -> kinesisClient.putRecords(new PutRecordsRequest())); +// txnAsync(() -> kinesisAsyncClient.putRecordsAsync(new PutRecordsRequest())); +// assertKinesisTrace("putRecords", false); +// } +// +// @Test +// public void testRemoveTagsFromStream() { +// txn(() -> kinesisClient.removeTagsFromStream(new RemoveTagsFromStreamRequest())); +// txnAsync(() -> kinesisAsyncClient.removeTagsFromStreamAsync(new RemoveTagsFromStreamRequest())); +// assertKinesisTrace("removeTagsFromStream", false); +// } +// +// @Test +// public void testSplitShard() { +// txn(() -> kinesisClient.splitShard(new SplitShardRequest())); +// txnAsync(() -> kinesisAsyncClient.splitShardAsync(new SplitShardRequest())); +// assertKinesisTrace("splitShard", false); +// } +// +// @Test +// public void testUpdateShardCount() { +// txn(() -> kinesisClient.updateShardCount(new UpdateShardCountRequest())); +// txnAsync(() -> kinesisAsyncClient.updateShardCountAsync(new UpdateShardCountRequest())); +// assertKinesisTrace("updateShardCount", false); +// } + + @Trace(dispatcher = true) + public void txn(Runnable runnable) { + try { + Thread.sleep(200); + runnable.run(); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Trace(dispatcher = true) + public void txnAsync(Supplier> function) { + try { + Thread.sleep(200); + function.get().get(); + } catch (Exception ignored) { + } + } + + @Trace(dispatcher = true) + public void txnAsyncWithHandler(Function, Future> function, AsyncHandler handler) { + try { + function.apply(handler).get(); + } catch (Exception ignored) { + } + } + + private void assertKinesisTrace(String kinesisOperation, boolean assertSpan) { + Introspector introspector = InstrumentationTestRunner.getIntrospector(); + final String traceName = "Kinesis/" + kinesisOperation; + if (assertSpan) { + // Span events fail to be generated when enough transactions are done in succession + List kinesisSpans = introspector.getSpanEvents().stream() + .filter(span -> traceName.equals(span.getName())) + .collect(Collectors.toList()); + assertEquals(2, kinesisSpans.size()); + for (SpanEvent kinesisSpan: kinesisSpans) { + assertEquals("aws_kinesis_data_streams", kinesisSpan.getAgentAttributes().get("cloud.platform")); + } + } + assertTxn(kinesisOperation, introspector); + assertTxnAsync(kinesisOperation, "OtherTransaction/Custom/com.amazonaws.services.kinesis.AmazonKinesisAPITest/txnAsync", introspector); + } + + private void assertTxn(String kinesisOperation, Introspector introspector) { + String transactionName = "OtherTransaction/Custom/com.amazonaws.services.kinesis.AmazonKinesisAPITest/txn"; + final String traceName = "Kinesis/" + kinesisOperation; + Collection transactionTraces = introspector.getTransactionTracesForTransaction(transactionName); + TransactionTrace transactionTrace = transactionTraces.iterator().next(); + List children = transactionTrace.getInitialTraceSegment().getChildren(); + assertEquals(1, children.size()); + TraceSegment trace = children.get(0); + assertEquals(traceName, trace.getName()); + assertEquals("aws_kinesis_data_streams", trace.getTracerAttributes().get("cloud.platform")); + } + + private void assertTxnAsync(String kinesisOperation, String transactionName, Introspector introspector) { + final String asyncClientTraceName = "Java/com.amazonaws.services.kinesis.AmazonKinesisAsyncClient/" + kinesisOperation + "Async"; + final String extTraceName = "Kinesis/" + kinesisOperation; + Collection transactionTraces = introspector.getTransactionTracesForTransaction(transactionName); + TransactionTrace transactionTrace = transactionTraces.iterator().next(); + + List rootChildren = transactionTrace.getInitialTraceSegment().getChildren(); + assertEquals(1, rootChildren.size()); + TraceSegment asyncClientTrace = rootChildren.get(0); + assertEquals(asyncClientTraceName, asyncClientTrace.getName()); + + List asyncFunctionTraceChildren = asyncClientTrace.getChildren(); + assertEquals(1, asyncFunctionTraceChildren.size()); + TraceSegment extTrace = asyncFunctionTraceChildren.get(0); + assertEquals(extTraceName, extTrace.getName()); + assertEquals("aws_kinesis_data_streams", extTrace.getTracerAttributes().get("cloud.platform")); + } + + private static class CredProvider implements AWSCredentialsProvider { + @Override + public AWSCredentials getCredentials() { + AWSCredentials credentials = mock(AWSCredentials.class); + when(credentials.getAWSAccessKeyId()).thenReturn("accessKeyId"); + when(credentials.getAWSSecretKey()).thenReturn("secretAccessKey"); + return credentials; + } + + @Override + public void refresh() { + + } + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-1.11.106/src/test/resources/dt_enabled.yml b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/test/resources/dt_enabled.yml new file mode 100644 index 0000000000..53b0968002 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-1.11.106/src/test/resources/dt_enabled.yml @@ -0,0 +1,5 @@ +common: &default_settings + distributed_tracing: + enabled: true + span_events: + enabled: true \ No newline at end of file diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/build.gradle b/instrumentation/aws-java-sdk-kinesis-2.0.6/build.gradle new file mode 100644 index 0000000000..bd30d61ce9 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/build.gradle @@ -0,0 +1,14 @@ +dependencies { + implementation(project(":agent-bridge")) + implementation("software.amazon.awssdk:kinesis:2.20.45") +} + +jar { + manifest { attributes 'Implementation-Title': 'com.newrelic.instrumentation.aws-java-sdk-kinesis-2.0.6' } +} + +verifyInstrumentation { + passes 'software.amazon.awssdk:kinesis:[2.1.0,)' + exclude 'software.amazon.awssdk:kinesis:2.17.200' // this version failed the test, but the next one works again. + excludeRegex '.*-preview-[0-9a-f]+' +} \ No newline at end of file diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/KinesisUtil.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/KinesisUtil.java new file mode 100644 index 0000000000..ce69329bee --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/KinesisUtil.java @@ -0,0 +1,30 @@ +package com.agent.instrumentation.awsjavasdk2.services.kinesis; + +import com.newrelic.api.agent.CloudParameters; +import com.newrelic.api.agent.NewRelic; +import com.newrelic.api.agent.Segment; +import com.newrelic.api.agent.TracedMethod; + +public class KinesisUtil { + + public static final String PLATFORM = "aws_kinesis_data_streams"; + public static final String TRACE_CATEGORY = "Kinesis"; + private KinesisUtil() {} + + public static Segment beginSegment(String kinesisOperation) { + Segment segment = NewRelic.getAgent().getTransaction().startSegment(TRACE_CATEGORY, kinesisOperation); + segment.reportAsExternal(createCloudParams()); + return segment; + } + + public static void setTraceDetails(String kinesisOperation) { + TracedMethod tracedMethod = NewRelic.getAgent().getTracedMethod(); + tracedMethod.setMetricName(TRACE_CATEGORY, kinesisOperation); + tracedMethod.reportAsExternal(createCloudParams()); + } + public static CloudParameters createCloudParams() { + // Todo: add arn to cloud parameters + return CloudParameters.provider(PLATFORM).build(); + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/SegmentHandler.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/SegmentHandler.java new file mode 100644 index 0000000000..d996af803a --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/com/agent/instrumentation/awsjavasdk2/services/kinesis/SegmentHandler.java @@ -0,0 +1,32 @@ +package com.agent.instrumentation.awsjavasdk2.services.kinesis; + +import com.newrelic.agent.bridge.AgentBridge; +import com.newrelic.api.agent.Segment; + +import java.util.concurrent.CompletableFuture; + +public class SegmentHandler { + private final CompletableFuture completableFuture; + private final Segment segment; + private final String implementationTitle; + + public SegmentHandler(CompletableFuture completableFuture, Segment segment, String implementationTitle) { + this.completableFuture = completableFuture; + this.segment = segment; + this.implementationTitle = implementationTitle; + } + + public CompletableFuture newSegmentCompletionStage() { + if (completableFuture == null) { + return null; + } + return completableFuture.whenComplete((r, t) -> { + try { + segment.reportAsExternal(KinesisUtil.createCloudParams()); + segment.end(); + } catch (Throwable t1) { + AgentBridge.instrumentation.noticeInstrumentationError(t1, implementationTitle); + } + }); + } +} \ No newline at end of file diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/core/client/handler/AsyncClientHandler_Instrumentation.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/core/client/handler/AsyncClientHandler_Instrumentation.java new file mode 100644 index 0000000000..17f8e249b5 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/core/client/handler/AsyncClientHandler_Instrumentation.java @@ -0,0 +1,28 @@ +package software.amazon.awssdk.core.client.handler; + +import com.newrelic.api.agent.Trace; +import com.newrelic.api.agent.weaver.MatchType; +import com.newrelic.api.agent.weaver.Weave; +import com.newrelic.api.agent.weaver.Weaver; +import software.amazon.awssdk.core.SdkRequest; +import software.amazon.awssdk.core.SdkResponse; +import software.amazon.awssdk.core.async.AsyncResponseTransformer; + +import java.util.concurrent.CompletableFuture; + +@Weave(originalName = "software.amazon.awssdk.core.client.handler.AsyncClientHandler", type = MatchType.Interface) +public class AsyncClientHandler_Instrumentation { + // This prevents further traces from forming when using the async client + @Trace(leaf = true, excludeFromTransactionTrace = true) + public CompletableFuture execute( + ClientExecutionParams executionParams) { + return Weaver.callOriginal(); + } + + @Trace(leaf = true, excludeFromTransactionTrace = true) + public CompletableFuture execute( + ClientExecutionParams executionParams, + AsyncResponseTransformer asyncResponseTransformer) { + return Weaver.callOriginal(); + } +} diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/services/kinesis/DefaultKinesisAsyncClient_Instrumentation.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/services/kinesis/DefaultKinesisAsyncClient_Instrumentation.java new file mode 100644 index 0000000000..29763c9dc8 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/services/kinesis/DefaultKinesisAsyncClient_Instrumentation.java @@ -0,0 +1,239 @@ +package software.amazon.awssdk.services.kinesis; + +import com.agent.instrumentation.awsjavasdk2.services.kinesis.KinesisUtil; +import com.agent.instrumentation.awsjavasdk2.services.kinesis.SegmentHandler; +import com.newrelic.api.agent.Segment; +import com.newrelic.api.agent.weaver.MatchType; +import com.newrelic.api.agent.weaver.Weave; +import com.newrelic.api.agent.weaver.Weaver; +import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamRequest; +import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamResponse; +import software.amazon.awssdk.services.kinesis.model.CreateStreamRequest; +import software.amazon.awssdk.services.kinesis.model.CreateStreamResponse; +import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodResponse; +import software.amazon.awssdk.services.kinesis.model.DeleteStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DeleteStreamResponse; +import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeLimitsRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeLimitsResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryRequest; +import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringResponse; +import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringResponse; +import software.amazon.awssdk.services.kinesis.model.GetRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.GetRecordsResponse; +import software.amazon.awssdk.services.kinesis.model.GetShardIteratorRequest; +import software.amazon.awssdk.services.kinesis.model.GetShardIteratorResponse; +import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodResponse; +import software.amazon.awssdk.services.kinesis.model.ListShardsRequest; +import software.amazon.awssdk.services.kinesis.model.ListShardsResponse; +import software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest; +import software.amazon.awssdk.services.kinesis.model.ListStreamConsumersResponse; +import software.amazon.awssdk.services.kinesis.model.ListStreamsRequest; +import software.amazon.awssdk.services.kinesis.model.ListStreamsResponse; +import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamRequest; +import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamResponse; +import software.amazon.awssdk.services.kinesis.model.MergeShardsRequest; +import software.amazon.awssdk.services.kinesis.model.MergeShardsResponse; +import software.amazon.awssdk.services.kinesis.model.PutRecordRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordResponse; +import software.amazon.awssdk.services.kinesis.model.PutRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordsResponse; +import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerResponse; +import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamRequest; +import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamResponse; +import software.amazon.awssdk.services.kinesis.model.SplitShardRequest; +import software.amazon.awssdk.services.kinesis.model.SplitShardResponse; +import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionResponse; +import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionResponse; +import software.amazon.awssdk.services.kinesis.model.SubscribeToShardRequest; +import software.amazon.awssdk.services.kinesis.model.SubscribeToShardResponseHandler; +import software.amazon.awssdk.services.kinesis.model.UpdateShardCountRequest; +import software.amazon.awssdk.services.kinesis.model.UpdateShardCountResponse; + +import java.util.concurrent.CompletableFuture; + +@Weave(originalName = "software.amazon.awssdk.services.kinesis.DefaultKinesisAsyncClient", type = MatchType.ExactClass) +class DefaultKinesisAsyncClient_Instrumentation { + + public CompletableFuture addTagsToStream(AddTagsToStreamRequest addTagsToStreamRequest) { + Segment segment = KinesisUtil.beginSegment("addTagsToStream"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture createStream(CreateStreamRequest createStreamRequest) { + Segment segment = KinesisUtil.beginSegment("createStream"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture decreaseStreamRetentionPeriod( + DecreaseStreamRetentionPeriodRequest decreaseStreamRetentionPeriodRequest) { + Segment segment = KinesisUtil.beginSegment("decreaseStreamRetentionPeriod"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture deleteStream(DeleteStreamRequest deleteStreamRequest) { + Segment segment = KinesisUtil.beginSegment("deleteStream"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture deregisterStreamConsumer(DeregisterStreamConsumerRequest deregisterStreamConsumerRequest) { + Segment segment = KinesisUtil.beginSegment("deregisterStreamConsumer"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture describeLimits(DescribeLimitsRequest describeLimitsRequest) { + Segment segment = KinesisUtil.beginSegment("describeLimits"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture describeStream(DescribeStreamRequest describeStreamRequest) { + Segment segment = KinesisUtil.beginSegment("describeStream"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture describeStreamConsumer(DescribeStreamConsumerRequest describeStreamConsumerRequest) { + Segment segment = KinesisUtil.beginSegment("describeStreamConsumer"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture describeStreamSummary(DescribeStreamSummaryRequest describeStreamSummaryRequest) { + Segment segment = KinesisUtil.beginSegment( "describeStreamSummary"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture disableEnhancedMonitoring(DisableEnhancedMonitoringRequest disableEnhancedMonitoringRequest) { + Segment segment = KinesisUtil.beginSegment("disableEnhancedMonitoring"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + public CompletableFuture enableEnhancedMonitoring(EnableEnhancedMonitoringRequest enableEnhancedMonitoringRequest) { + Segment segment = KinesisUtil.beginSegment("enableEnhancedMonitoring"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture getRecords(GetRecordsRequest getRecordsRequest) { + Segment segment = KinesisUtil.beginSegment("getRecords"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture getShardIterator(GetShardIteratorRequest getShardIteratorRequest) { + Segment segment = KinesisUtil.beginSegment("getShardIterator"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture increaseStreamRetentionPeriod( + IncreaseStreamRetentionPeriodRequest increaseStreamRetentionPeriodRequest) { + Segment segment = KinesisUtil.beginSegment("increaseStreamRetentionPeriod"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture listShards(ListShardsRequest listShardsRequest) { + Segment segment = KinesisUtil.beginSegment("listShards"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture listStreamConsumers(ListStreamConsumersRequest listStreamConsumersRequest) { + Segment segment = KinesisUtil.beginSegment("listStreamConsumers"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture listStreams(ListStreamsRequest listStreamsRequest) { + Segment segment = KinesisUtil.beginSegment("listStreams"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture listTagsForStream(ListTagsForStreamRequest listTagsForStreamRequest) { + Segment segment = KinesisUtil.beginSegment("listTagsForStream"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture mergeShards(MergeShardsRequest mergeShardsRequest) { + Segment segment = KinesisUtil.beginSegment("mergeShards"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture putRecord(PutRecordRequest putRecordRequest) { + Segment segment = KinesisUtil.beginSegment("putRecord"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture putRecords(PutRecordsRequest putRecordsRequest) { + Segment segment = KinesisUtil.beginSegment("putRecords"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture registerStreamConsumer(RegisterStreamConsumerRequest registerStreamConsumerRequest) { + Segment segment = KinesisUtil.beginSegment("registerStreamConsumer"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture removeTagsFromStream(RemoveTagsFromStreamRequest removeTagsFromStreamRequest) { + Segment segment = KinesisUtil.beginSegment("removeTagsFromStream"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture splitShard(SplitShardRequest splitShardRequest) { + Segment segment = KinesisUtil.beginSegment("splitShard"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture startStreamEncryption(StartStreamEncryptionRequest startStreamEncryptionRequest) { + Segment segment = KinesisUtil.beginSegment("startStreamEncryption"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture stopStreamEncryption(StopStreamEncryptionRequest stopStreamEncryptionRequest) { + Segment segment = KinesisUtil.beginSegment("stopStreamEncryption"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture subscribeToShard(SubscribeToShardRequest subscribeToShardRequest, SubscribeToShardResponseHandler asyncResponseHandler) { + Segment segment = KinesisUtil.beginSegment("stopStreamEncryption"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + + public CompletableFuture updateShardCount(UpdateShardCountRequest updateShardCountRequest) { + Segment segment = KinesisUtil.beginSegment("updateShardCount"); + CompletableFuture response = Weaver.callOriginal(); + return new SegmentHandler<>(response, segment, Weaver.getImplementationTitle()).newSegmentCompletionStage(); + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/services/kinesis/DefaultKinesisClient_Instrumentation.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/services/kinesis/DefaultKinesisClient_Instrumentation.java new file mode 100644 index 0000000000..04ae89282a --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/main/java/software/amazon/awssdk/services/kinesis/DefaultKinesisClient_Instrumentation.java @@ -0,0 +1,227 @@ +package software.amazon.awssdk.services.kinesis; + +import com.agent.instrumentation.awsjavasdk2.services.kinesis.KinesisUtil; +import com.newrelic.api.agent.Trace; +import com.newrelic.api.agent.weaver.MatchType; +import com.newrelic.api.agent.weaver.Weave; +import com.newrelic.api.agent.weaver.Weaver; +import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamRequest; +import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamResponse; +import software.amazon.awssdk.services.kinesis.model.CreateStreamRequest; +import software.amazon.awssdk.services.kinesis.model.CreateStreamResponse; +import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodResponse; +import software.amazon.awssdk.services.kinesis.model.DeleteStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DeleteStreamResponse; +import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeLimitsRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeLimitsResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamResponse; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryResponse; +import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringResponse; +import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringResponse; +import software.amazon.awssdk.services.kinesis.model.GetRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.GetRecordsResponse; +import software.amazon.awssdk.services.kinesis.model.GetShardIteratorRequest; +import software.amazon.awssdk.services.kinesis.model.GetShardIteratorResponse; +import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodResponse; +import software.amazon.awssdk.services.kinesis.model.ListShardsRequest; +import software.amazon.awssdk.services.kinesis.model.ListShardsResponse; +import software.amazon.awssdk.services.kinesis.model.ListStreamConsumersRequest; +import software.amazon.awssdk.services.kinesis.model.ListStreamConsumersResponse; +import software.amazon.awssdk.services.kinesis.model.ListStreamsRequest; +import software.amazon.awssdk.services.kinesis.model.ListStreamsResponse; +import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamRequest; +import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamResponse; +import software.amazon.awssdk.services.kinesis.model.MergeShardsRequest; +import software.amazon.awssdk.services.kinesis.model.MergeShardsResponse; +import software.amazon.awssdk.services.kinesis.model.PutRecordRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordResponse; +import software.amazon.awssdk.services.kinesis.model.PutRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordsResponse; +import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerResponse; +import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamRequest; +import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamResponse; +import software.amazon.awssdk.services.kinesis.model.SplitShardRequest; +import software.amazon.awssdk.services.kinesis.model.SplitShardResponse; +import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionResponse; +import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionResponse; +import software.amazon.awssdk.services.kinesis.model.UpdateShardCountRequest; +import software.amazon.awssdk.services.kinesis.model.UpdateShardCountResponse; + +@Weave(originalName = "software.amazon.awssdk.services.kinesis.DefaultKinesisClient", type = MatchType.ExactClass) +class DefaultKinesisClient_Instrumentation { + @Trace(leaf=true) + public AddTagsToStreamResponse addTagsToStream(AddTagsToStreamRequest addTagsToStreamRequest) { + KinesisUtil.setTraceDetails("addTagsToStream"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public CreateStreamResponse createStream(CreateStreamRequest createStreamRequest) { + KinesisUtil.setTraceDetails("createStream"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DecreaseStreamRetentionPeriodResponse decreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest decreaseStreamRetentionPeriodRequest) { + KinesisUtil.setTraceDetails("decreaseStreamRetentionPeriod"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DeleteStreamResponse deleteStream(DeleteStreamRequest deleteStreamRequest) { + KinesisUtil.setTraceDetails("deleteStream"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DeregisterStreamConsumerResponse deregisterStreamConsumer(DeregisterStreamConsumerRequest deregisterStreamConsumerRequest) { + KinesisUtil.setTraceDetails("deregisterStreamConsumer"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DescribeLimitsResponse describeLimits(DescribeLimitsRequest describeLimitsRequest) { + KinesisUtil.setTraceDetails("describeLimits"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DescribeStreamResponse describeStream(DescribeStreamRequest describeStreamRequest) { + KinesisUtil.setTraceDetails("describeStream"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DescribeStreamConsumerResponse describeStreamConsumer(DescribeStreamConsumerRequest describeStreamConsumerRequest) { + KinesisUtil.setTraceDetails("describeStreamConsumer"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DescribeStreamSummaryResponse describeStreamSummary(DescribeStreamSummaryRequest describeStreamSummaryRequest) { + KinesisUtil.setTraceDetails("describeStreamSummary"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public DisableEnhancedMonitoringResponse disableEnhancedMonitoring(DisableEnhancedMonitoringRequest disableEnhancedMonitoringRequest) { + KinesisUtil.setTraceDetails("disableEnhancedMonitoring"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public EnableEnhancedMonitoringResponse enableEnhancedMonitoring(EnableEnhancedMonitoringRequest enableEnhancedMonitoringRequest) { + KinesisUtil.setTraceDetails("enableEnhancedMonitoring"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public GetRecordsResponse getRecords(GetRecordsRequest getRecordsRequest) { + KinesisUtil.setTraceDetails("getRecords"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public GetShardIteratorResponse getShardIterator(GetShardIteratorRequest getShardIteratorRequest) { + KinesisUtil.setTraceDetails("getShardIterator"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public IncreaseStreamRetentionPeriodResponse increaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest increaseStreamRetentionPeriodRequest) { + KinesisUtil.setTraceDetails("increaseStreamRetentionPeriod"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public ListShardsResponse listShards(ListShardsRequest listShardsRequest) { + KinesisUtil.setTraceDetails("listShards"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public ListStreamConsumersResponse listStreamConsumers(ListStreamConsumersRequest listStreamConsumersRequest) { + KinesisUtil.setTraceDetails("listStreamConsumers"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public ListStreamsResponse listStreams(ListStreamsRequest listStreamsRequest) { + KinesisUtil.setTraceDetails("listStreams"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public ListTagsForStreamResponse listTagsForStream(ListTagsForStreamRequest listTagsForStreamRequest) { + KinesisUtil.setTraceDetails("listTagsForStream"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public MergeShardsResponse mergeShards(MergeShardsRequest mergeShardsRequest) { + KinesisUtil.setTraceDetails("mergeShards"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public PutRecordResponse putRecord(PutRecordRequest putRecordRequest) { + KinesisUtil.setTraceDetails("putRecord"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public PutRecordsResponse putRecords(PutRecordsRequest putRecordsRequest) { + KinesisUtil.setTraceDetails("putRecords"); + return Weaver.callOriginal(); + } + @Trace(leaf=true) + public RegisterStreamConsumerResponse registerStreamConsumer(RegisterStreamConsumerRequest registerStreamConsumerRequest) { + KinesisUtil.setTraceDetails("registerStreamConsumer"); + return Weaver.callOriginal(); + } + + + @Trace(leaf=true) + public RemoveTagsFromStreamResponse removeTagsFromStream(RemoveTagsFromStreamRequest removeTagsFromStreamRequest) { + KinesisUtil.setTraceDetails("removeTagsFromStream"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public SplitShardResponse splitShard(SplitShardRequest splitShardRequest) { + KinesisUtil.setTraceDetails("splitShard"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public StartStreamEncryptionResponse startStreamEncryption(StartStreamEncryptionRequest startStreamEncryptionRequest) { + KinesisUtil.setTraceDetails("startStreamEncryption"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public StopStreamEncryptionResponse stopStreamEncryption(StopStreamEncryptionRequest stopStreamEncryptionRequest) { + KinesisUtil.setTraceDetails("stopStreamEncryption"); + return Weaver.callOriginal(); + } + + @Trace(leaf=true) + public UpdateShardCountResponse updateShardCount(UpdateShardCountRequest updateShardCountRequest) { + KinesisUtil.setTraceDetails("updateShardCount"); + return Weaver.callOriginal(); + } + +} diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/java/software/amazon/awssdk/services/kinesis/DefaultKinesisAsyncClientTest.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/java/software/amazon/awssdk/services/kinesis/DefaultKinesisAsyncClientTest.java new file mode 100644 index 0000000000..e64542b05f --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/java/software/amazon/awssdk/services/kinesis/DefaultKinesisAsyncClientTest.java @@ -0,0 +1,315 @@ +package software.amazon.awssdk.services.kinesis; + +import com.newrelic.agent.introspec.InstrumentationTestConfig; +import com.newrelic.agent.introspec.InstrumentationTestRunner; +import com.newrelic.agent.introspec.Introspector; +import com.newrelic.agent.introspec.SpanEvent; +import com.newrelic.agent.introspec.TraceSegment; +import com.newrelic.agent.introspec.TransactionTrace; +import com.newrelic.api.agent.Trace; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import software.amazon.awssdk.auth.credentials.AwsCredentials; +import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider; +import software.amazon.awssdk.core.async.EmptyPublisher; +import software.amazon.awssdk.http.AbortableInputStream; +import software.amazon.awssdk.http.ExecutableHttpRequest; +import software.amazon.awssdk.http.HttpExecuteResponse; +import software.amazon.awssdk.http.SdkHttpFullResponse; +import software.amazon.awssdk.http.async.AsyncExecuteRequest; +import software.amazon.awssdk.http.async.SdkAsyncHttpClient; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamRequest; +import software.amazon.awssdk.services.kinesis.model.CreateStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.DeleteStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeLimitsRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryRequest; +import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.GetRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.GetShardIteratorRequest; +import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.ListShardsRequest; +import software.amazon.awssdk.services.kinesis.model.ListStreamsRequest; +import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamRequest; +import software.amazon.awssdk.services.kinesis.model.MergeShardsRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamRequest; +import software.amazon.awssdk.services.kinesis.model.SplitShardRequest; +import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.UpdateShardCountRequest; +import software.amazon.awssdk.utils.StringInputStream; + +import java.io.IOException; +import java.util.Collection; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; +import java.util.function.Supplier; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@RunWith(InstrumentationTestRunner.class) +@InstrumentationTestConfig(includePrefixes = {"software.amazon.awssdk"}, configName = "dt_enabled.yml") +public class DefaultKinesisAsyncClientTest { + public KinesisAsyncClient kinesisAsyncClient; + public HttpExecuteResponse response; + + @Before + public void setup() { + AsyncHttpClient mockHttpClient = new AsyncHttpClient(); + response = mockHttpClient.getResponse(); + kinesisAsyncClient = KinesisAsyncClient.builder() + .httpClient(mockHttpClient) + .credentialsProvider(new CredProvider()) + .region(Region.US_EAST_1) + .build(); + } + + @Test + public void testAddTagsToStream() { + txn(() -> kinesisAsyncClient.addTagsToStream(AddTagsToStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/addTagsToStream", true); + } + + @Test + public void testCreateStream() { + txn(() -> kinesisAsyncClient.createStream(CreateStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/createStream", false); + } + + @Test + public void testDecreaseStreamRetentionPeriod() { + txn(() -> kinesisAsyncClient.decreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest.builder().build())); + assertKinesisTrace("Kinesis/decreaseStreamRetentionPeriod", false); + } + + @Test + public void testDeleteStream() { + txn(() -> kinesisAsyncClient.deleteStream(DeleteStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/deleteStream", false); + } + + @Test + public void testDeregisterStreamConsumer() { + txn(() -> kinesisAsyncClient.deregisterStreamConsumer(DeregisterStreamConsumerRequest.builder().build())); + assertKinesisTrace("Kinesis/deregisterStreamConsumer", false); + } + + @Test + public void testDescribeLimits() { + txn(() -> kinesisAsyncClient.describeLimits(DescribeLimitsRequest.builder().build())); + assertKinesisTrace("Kinesis/describeLimits", false); + } + + @Test + public void testDescribeStream() { + txn(() -> kinesisAsyncClient.describeStream(DescribeStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/describeStream", false); + } + + @Test + public void testDescribeStreamConsumer() { + txn(() -> kinesisAsyncClient.describeStreamConsumer(DescribeStreamConsumerRequest.builder().build())); + assertKinesisTrace("Kinesis/describeStreamConsumer", false); + } + + @Test + public void testDescribeStreamSummary() { + txn(() -> kinesisAsyncClient.describeStreamSummary(DescribeStreamSummaryRequest.builder().build())); + assertKinesisTrace("Kinesis/describeStreamSummary", false); + } + + @Test + public void DisableEnhancedMonitoring() { + txn(() -> kinesisAsyncClient.disableEnhancedMonitoring(DisableEnhancedMonitoringRequest.builder().build())); + assertKinesisTrace("Kinesis/disableEnhancedMonitoring", false); + } + + @Test + public void testEnableEnhancedMonitoring() { + txn(() -> kinesisAsyncClient.enableEnhancedMonitoring(EnableEnhancedMonitoringRequest.builder().build())); + assertKinesisTrace("Kinesis/enableEnhancedMonitoring", false); + } + + @Test + public void testGetRecords() { + txn(() -> kinesisAsyncClient.getRecords(GetRecordsRequest.builder().build())); + assertKinesisTrace("Kinesis/getRecords", false); + } + + @Test + public void testGetShardIterator() { + txn(() -> kinesisAsyncClient.getShardIterator(GetShardIteratorRequest.builder().build())); + assertKinesisTrace("Kinesis/getShardIterator", false); + } + + @Test + public void testIncreaseStreamRetentionPeriod() { + txn(() -> kinesisAsyncClient.increaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest.builder().build())); + assertKinesisTrace("Kinesis/increaseStreamRetentionPeriod", false); + } + + @Test + public void testListShards() { + txn(() -> kinesisAsyncClient.listShards(ListShardsRequest.builder().build())); + assertKinesisTrace("Kinesis/listShards", false); + } + + @Test + public void testListStreams() { + txn(() -> kinesisAsyncClient.listStreams(ListStreamsRequest.builder().build())); + assertKinesisTrace("Kinesis/listStreams", false); + } + + @Test + public void testListTagsForStream() { + txn(() -> kinesisAsyncClient.listTagsForStream(ListTagsForStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/listTagsForStream", false); + } + + @Test + public void testMergeShards() { + txn(() -> kinesisAsyncClient.mergeShards(MergeShardsRequest.builder().build())); + assertKinesisTrace("Kinesis/mergeShards", false); + } + + @Test + public void testPutRecord() { + txn(() -> kinesisAsyncClient.putRecord(PutRecordRequest.builder().build())); + assertKinesisTrace("Kinesis/putRecord", false); + } + + @Test + public void testPutRecords() { + txn(() -> kinesisAsyncClient.putRecords(PutRecordsRequest.builder().build())); + assertKinesisTrace("Kinesis/putRecords", false); + } + + @Test + public void testRegisterStreamConsumer() { + txn(() -> kinesisAsyncClient.registerStreamConsumer(RegisterStreamConsumerRequest.builder().build())); + assertKinesisTrace("Kinesis/registerStreamConsumer", false); + } + + @Test + public void testRemoveTagsFromStream() { + txn(() -> kinesisAsyncClient.removeTagsFromStream(RemoveTagsFromStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/removeTagsFromStream", false); + } + + @Test + public void testSplitShard() { + txn(() -> kinesisAsyncClient.splitShard(SplitShardRequest.builder().build())); + assertKinesisTrace("Kinesis/splitShard", false); + } + + @Test + public void testStartStreamEncryption() { + txn(() -> kinesisAsyncClient.startStreamEncryption(StartStreamEncryptionRequest.builder().build())); + assertKinesisTrace("Kinesis/startStreamEncryption", false); + } + + @Test + public void testStopStreamEncryption() { + txn(() -> kinesisAsyncClient.stopStreamEncryption(StopStreamEncryptionRequest.builder().build())); + assertKinesisTrace("Kinesis/stopStreamEncryption", false); + } + + @Test + public void testUpdateShardCount() { + txn(() -> kinesisAsyncClient.updateShardCount(UpdateShardCountRequest.builder().build())); + assertKinesisTrace("Kinesis/updateShardCount", false); + } + + @Trace(dispatcher = true) + private void txn(Supplier> supplier) { + supplier.get(); + } + + private void assertKinesisTrace(String traceName, boolean assertSpan) { + Introspector introspector = InstrumentationTestRunner.getIntrospector(); + if (assertSpan) { + // Span events fail to be generated when enough transactions are done in succession + SpanEvent kinesisSpan = introspector.getSpanEvents().stream() + .filter(span -> traceName.equals(span.getName())) + .findFirst().orElse(null); + assertNotNull(kinesisSpan); + assertEquals("aws_kinesis_data_streams", kinesisSpan.getAgentAttributes().get("cloud.platform")); + } + Collection transactionTraces = introspector.getTransactionTracesForTransaction( + "OtherTransaction/Custom/software.amazon.awssdk.services.kinesis.DefaultKinesisAsyncClientTest/txn"); + TransactionTrace transactionTrace = transactionTraces.iterator().next(); + List children = transactionTrace.getInitialTraceSegment().getChildren(); + assertEquals(1, children.size()); + TraceSegment trace = children.get(0); + assertEquals(traceName, trace.getName()); + assertEquals("aws_kinesis_data_streams", trace.getTracerAttributes().get("cloud.platform")); + } + + // This mock SdkAsyncHttpClient allows testing the AWS SDK without making actual HTTP requests. + private static class AsyncHttpClient implements SdkAsyncHttpClient { + private ExecutableHttpRequest executableMock; + private HttpExecuteResponse response; + private SdkHttpFullResponse httpResponse; + + public AsyncHttpClient() { + executableMock = mock(ExecutableHttpRequest.class); + response = mock(HttpExecuteResponse.class, Mockito.RETURNS_DEEP_STUBS); + httpResponse = mock(SdkHttpFullResponse.class, Mockito.RETURNS_DEEP_STUBS); + when(response.httpResponse()).thenReturn(httpResponse); + when(httpResponse.toBuilder().content(any()).build()).thenReturn(httpResponse); + when(httpResponse.isSuccessful()).thenReturn(true); + AbortableInputStream inputStream = AbortableInputStream.create(new StringInputStream("Dont panic")); + when(httpResponse.content()).thenReturn(Optional.of(inputStream)); + try { + when(executableMock.call()).thenReturn(response); + + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + @Override + public void close() { + } + + @Override + public CompletableFuture execute(AsyncExecuteRequest asyncExecuteRequest) { + asyncExecuteRequest.responseHandler().onStream(new EmptyPublisher<>()); + return new CompletableFuture<>(); + } + + @Override + public String clientName() { + return "MockHttpClient"; + } + + public HttpExecuteResponse getResponse() { + return response; + } + } + + private static class CredProvider implements AwsCredentialsProvider { + @Override + public AwsCredentials resolveCredentials() { + AwsCredentials credentials = mock(AwsCredentials.class); + when(credentials.accessKeyId()).thenReturn("accessKeyId"); + when(credentials.secretAccessKey()).thenReturn("secretAccessKey"); + return credentials; + } + } +} diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/java/software/amazon/awssdk/services/kinesis/DefaultKinesisClientTest.java b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/java/software/amazon/awssdk/services/kinesis/DefaultKinesisClientTest.java new file mode 100644 index 0000000000..d70b4274bd --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/java/software/amazon/awssdk/services/kinesis/DefaultKinesisClientTest.java @@ -0,0 +1,311 @@ +package software.amazon.awssdk.services.kinesis; + +import com.newrelic.agent.introspec.InstrumentationTestConfig; +import com.newrelic.agent.introspec.InstrumentationTestRunner; +import com.newrelic.agent.introspec.Introspector; +import com.newrelic.agent.introspec.SpanEvent; +import com.newrelic.agent.introspec.TraceSegment; +import com.newrelic.agent.introspec.TransactionTrace; +import com.newrelic.api.agent.Trace; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import software.amazon.awssdk.auth.credentials.AwsCredentials; +import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider; +import software.amazon.awssdk.http.AbortableInputStream; +import software.amazon.awssdk.http.ExecutableHttpRequest; +import software.amazon.awssdk.http.HttpExecuteRequest; +import software.amazon.awssdk.http.HttpExecuteResponse; +import software.amazon.awssdk.http.SdkHttpClient; +import software.amazon.awssdk.http.SdkHttpFullResponse; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.kinesis.model.AddTagsToStreamRequest; +import software.amazon.awssdk.services.kinesis.model.CreateStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DecreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.DeleteStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DeregisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeLimitsRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamRequest; +import software.amazon.awssdk.services.kinesis.model.DescribeStreamSummaryRequest; +import software.amazon.awssdk.services.kinesis.model.DisableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.EnableEnhancedMonitoringRequest; +import software.amazon.awssdk.services.kinesis.model.GetRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.GetShardIteratorRequest; +import software.amazon.awssdk.services.kinesis.model.IncreaseStreamRetentionPeriodRequest; +import software.amazon.awssdk.services.kinesis.model.ListShardsRequest; +import software.amazon.awssdk.services.kinesis.model.ListStreamsRequest; +import software.amazon.awssdk.services.kinesis.model.ListTagsForStreamRequest; +import software.amazon.awssdk.services.kinesis.model.MergeShardsRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordRequest; +import software.amazon.awssdk.services.kinesis.model.PutRecordsRequest; +import software.amazon.awssdk.services.kinesis.model.RegisterStreamConsumerRequest; +import software.amazon.awssdk.services.kinesis.model.RemoveTagsFromStreamRequest; +import software.amazon.awssdk.services.kinesis.model.SplitShardRequest; +import software.amazon.awssdk.services.kinesis.model.StartStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.StopStreamEncryptionRequest; +import software.amazon.awssdk.services.kinesis.model.UpdateShardCountRequest; +import software.amazon.awssdk.utils.StringInputStream; + +import java.io.IOException; +import java.util.Collection; +import java.util.List; +import java.util.Optional; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@RunWith(InstrumentationTestRunner.class) +@InstrumentationTestConfig(includePrefixes = {"software.amazon.awssdk"}, configName = "dt_enabled.yml") +public class DefaultKinesisClientTest { + + public KinesisClient kinesisClient; + public HttpExecuteResponse response; + + @Before + public void setup() { + MockHttpClient mockHttpClient = new MockHttpClient(); + response = mockHttpClient.getResponse(); + kinesisClient = KinesisClient.builder() + .httpClient(mockHttpClient) + .credentialsProvider(new CredProvider()) + .region(Region.US_EAST_1) + .build(); + } + + @Test + public void testAddTagsToStream() { + txn(() -> kinesisClient.addTagsToStream(AddTagsToStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/addTagsToStream", true); + } + + @Test + public void testCreateStream() { + txn(() -> kinesisClient.createStream(CreateStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/createStream", false); + } + + @Test + public void testDecreaseStreamRetentionPeriod() { + txn(() -> kinesisClient.decreaseStreamRetentionPeriod(DecreaseStreamRetentionPeriodRequest.builder().build())); + assertKinesisTrace("Kinesis/decreaseStreamRetentionPeriod", false); + } + + @Test + public void testDeleteStream() { + txn(() -> kinesisClient.deleteStream(DeleteStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/deleteStream", false); + } + + @Test + public void testDeregisterStreamConsumer() { + txn(() -> kinesisClient.deregisterStreamConsumer(DeregisterStreamConsumerRequest.builder().build())); + assertKinesisTrace("Kinesis/deregisterStreamConsumer", false); + } + + @Test + public void testDescribeLimits() { + txn(() -> kinesisClient.describeLimits(DescribeLimitsRequest.builder().build())); + assertKinesisTrace("Kinesis/describeLimits", false); + } + + @Test + public void testDescribeStream() { + txn(() -> kinesisClient.describeStream(DescribeStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/describeStream", false); + } + + @Test + public void testDescribeStreamConsumer() { + txn(() -> kinesisClient.describeStreamConsumer(DescribeStreamConsumerRequest.builder().build())); + assertKinesisTrace("Kinesis/describeStreamConsumer", false); + } + + @Test + public void testDescribeStreamSummary() { + txn(() -> kinesisClient.describeStreamSummary(DescribeStreamSummaryRequest.builder().build())); + assertKinesisTrace("Kinesis/describeStreamSummary", false); + } + + @Test + public void DisableEnhancedMonitoring() { + txn(() -> kinesisClient.disableEnhancedMonitoring(DisableEnhancedMonitoringRequest.builder().build())); + assertKinesisTrace("Kinesis/disableEnhancedMonitoring", false); + } + + @Test + public void testEnableEnhancedMonitoring() { + txn(() -> kinesisClient.enableEnhancedMonitoring(EnableEnhancedMonitoringRequest.builder().build())); + assertKinesisTrace("Kinesis/enableEnhancedMonitoring", false); + } + + @Test + public void testGetRecords() { + txn(() -> kinesisClient.getRecords(GetRecordsRequest.builder().build())); + assertKinesisTrace("Kinesis/getRecords", false); + } + + @Test + public void testGetShardIterator() { + txn(() -> kinesisClient.getShardIterator(GetShardIteratorRequest.builder().build())); + assertKinesisTrace("Kinesis/getShardIterator", false); + } + + @Test + public void testIncreaseStreamRetentionPeriod() { + txn(() -> kinesisClient.increaseStreamRetentionPeriod(IncreaseStreamRetentionPeriodRequest.builder().build())); + assertKinesisTrace("Kinesis/increaseStreamRetentionPeriod", false); + } + + @Test + public void testListShards() { + txn(() -> kinesisClient.listShards(ListShardsRequest.builder().build())); + assertKinesisTrace("Kinesis/listShards", false); + } + + @Test + public void testListStreams() { + txn(() -> kinesisClient.listStreams(ListStreamsRequest.builder().build())); + assertKinesisTrace("Kinesis/listStreams", false); + } + + @Test + public void testListTagsForStream() { + txn(() -> kinesisClient.listTagsForStream(ListTagsForStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/listTagsForStream", false); + } + + @Test + public void testMergeShards() { + txn(() -> kinesisClient.mergeShards(MergeShardsRequest.builder().build())); + assertKinesisTrace("Kinesis/mergeShards", false); + } + + @Test + public void testPutRecord() { + txn(() -> kinesisClient.putRecord(PutRecordRequest.builder().build())); + assertKinesisTrace("Kinesis/putRecord", false); + } + + @Test + public void testPutRecords() { + txn(() -> kinesisClient.putRecords(PutRecordsRequest.builder().build())); + assertKinesisTrace("Kinesis/putRecords", false); + } + + @Test + public void testRegisterStreamConsumer() { + txn(() -> kinesisClient.registerStreamConsumer(RegisterStreamConsumerRequest.builder().build())); + assertKinesisTrace("Kinesis/registerStreamConsumer", false); + } + + @Test + public void testRemoveTagsFromStream() { + txn(() -> kinesisClient.removeTagsFromStream(RemoveTagsFromStreamRequest.builder().build())); + assertKinesisTrace("Kinesis/removeTagsFromStream", false); + } + + @Test + public void testSplitShard() { + txn(() -> kinesisClient.splitShard(SplitShardRequest.builder().build())); + assertKinesisTrace("Kinesis/splitShard", false); + } + + @Test + public void testStartStreamEncryption() { + txn(() -> kinesisClient.startStreamEncryption(StartStreamEncryptionRequest.builder().build())); + assertKinesisTrace("Kinesis/startStreamEncryption", false); + } + + @Test + public void testStopStreamEncryption() { + txn(() -> kinesisClient.stopStreamEncryption(StopStreamEncryptionRequest.builder().build())); + assertKinesisTrace("Kinesis/stopStreamEncryption", false); + } + + @Test + public void testUpdateShardCount() { + txn(() -> kinesisClient.updateShardCount(UpdateShardCountRequest.builder().build())); + assertKinesisTrace("Kinesis/updateShardCount", false); + } + + @Trace(dispatcher = true) + private void txn(Runnable runnable) { + runnable.run(); + } + + private void assertKinesisTrace(String traceName, boolean assertSpan) { + Introspector introspector = InstrumentationTestRunner.getIntrospector(); + if (assertSpan) { + // Span events fail to be generated when enough transactions are done in succession + SpanEvent kinesisSpan = introspector.getSpanEvents().stream() + .filter(span -> traceName.equals(span.getName())) + .findFirst().orElse(null); + assertNotNull(kinesisSpan); + assertEquals("aws_kinesis_data_streams", kinesisSpan.getAgentAttributes().get("cloud.platform")); + } + Collection transactionTraces = introspector.getTransactionTracesForTransaction( + "OtherTransaction/Custom/software.amazon.awssdk.services.kinesis.DefaultKinesisClientTest/txn"); + TransactionTrace transactionTrace = transactionTraces.iterator().next(); + List children = transactionTrace.getInitialTraceSegment().getChildren(); + assertEquals(1, children.size()); + TraceSegment trace = children.get(0); + assertEquals(traceName, trace.getName()); + assertEquals("aws_kinesis_data_streams", trace.getTracerAttributes().get("cloud.platform")); + } + + private static class MockHttpClient implements SdkHttpClient { + private final ExecutableHttpRequest executableMock; + private final HttpExecuteResponse response; + private final SdkHttpFullResponse httpResponse; + + public MockHttpClient() { + executableMock = mock(ExecutableHttpRequest.class); + response = mock(HttpExecuteResponse.class, Mockito.RETURNS_DEEP_STUBS); + httpResponse = mock(SdkHttpFullResponse.class, Mockito.RETURNS_DEEP_STUBS); + when(response.httpResponse()).thenReturn(httpResponse); + when(httpResponse.toBuilder().content(any()).build()).thenReturn(httpResponse); + when(httpResponse.isSuccessful()).thenReturn(true); + AbortableInputStream inputStream = AbortableInputStream.create(new StringInputStream("42")); + when(httpResponse.content()).thenReturn(Optional.of(inputStream)); + try { + when(executableMock.call()).thenReturn(response); + + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + @Override + public void close() { + } + + @Override + public ExecutableHttpRequest prepareRequest(HttpExecuteRequest httpExecuteRequest) { + return executableMock; + } + + @Override + public String clientName() { + return "MockHttpClient"; + } + + public HttpExecuteResponse getResponse() { + return response; + } + } + + private static class CredProvider implements AwsCredentialsProvider { + @Override + public AwsCredentials resolveCredentials() { + AwsCredentials credentials = mock(AwsCredentials.class); + when(credentials.accessKeyId()).thenReturn("accessKeyId"); + when(credentials.secretAccessKey()).thenReturn("secretAccessKey"); + return credentials; + } + } +} diff --git a/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/resources/dt_enabled.yml b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/resources/dt_enabled.yml new file mode 100644 index 0000000000..53b0968002 --- /dev/null +++ b/instrumentation/aws-java-sdk-kinesis-2.0.6/src/test/resources/dt_enabled.yml @@ -0,0 +1,5 @@ +common: &default_settings + distributed_tracing: + enabled: true + span_events: + enabled: true \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index 1e2a07ecc6..05cade8521 100644 --- a/settings.gradle +++ b/settings.gradle @@ -72,6 +72,8 @@ include 'instrumentation:anorm-2.4' include 'instrumentation:aws-bedrock-runtime-2.20' include 'instrumentation:aws-java-sdk-dynamodb-1.11.106' include 'instrumentation:aws-java-sdk-dynamodb-2.15.34' +include 'instrumentation:aws-java-sdk-kinesis-1.11.106' +include 'instrumentation:aws-java-sdk-kinesis-2.0.6' include 'instrumentation:aws-java-sdk-lambda-1.11.280' include 'instrumentation:aws-java-sdk-lambda-2.1' include 'instrumentation:aws-java-sdk-sqs-1.10.44'