Where:
filter - The name of the subscription filter (for example, MyFilter).
logGroup - The name of the log group. (for example, testgroup).
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String filter = args[0];
String logGroup = args[1];
CloudWatchLogsClient logs = CloudWatchLogsClient.builder()
.build();
deleteSubFilter(logs, filter, logGroup);
logs.close();
}
public static void deleteSubFilter(CloudWatchLogsClient logs, String filter, String logGroup) {
try {
DeleteSubscriptionFilterRequest request = DeleteSubscriptionFilterRequest.builder()
.filterName(filter)
.logGroupName(logGroup)
.build();
logs.deleteSubscriptionFilter(request);
System.out.printf("Successfully deleted CloudWatch logs subscription filter %s", filter);
} catch (CloudWatchException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteSubscriptionFilter](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/DeleteSubscriptionFilter)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cloudwatch-logs#code-examples).
```
import { DeleteSubscriptionFilterCommand } from "@aws-sdk/client-cloudwatch-logs";
import { client } from "../libs/client.js";
const run = async () => {
const command = new DeleteSubscriptionFilterCommand({
// The name of the filter.
filterName: process.env.CLOUDWATCH_LOGS_FILTER_NAME,
// The name of the log group.
logGroupName: process.env.CLOUDWATCH_LOGS_LOG_GROUP,
});
try {
return await client.send(command);
} catch (err) {
console.error(err);
}
};
export default run();
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteSubscriptionFilter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DeleteSubscriptionFilterCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/cloudwatch-logs#code-examples).
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the CloudWatchLogs service object
var cwl = new AWS.CloudWatchLogs({ apiVersion: "2014-03-28" });
var params = {
filterName: "FILTER",
logGroupName: "LOG_GROUP",
};
cwl.deleteSubscriptionFilter(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/cloudwatch-examples-subscriptions.html#cloudwatch-examples-subscriptions-deleting).
+ Pour plus de détails sur l'API, reportez-vous [DeleteSubscriptionFilter](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/logs-2014-03-28/DeleteSubscriptionFilter)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/cloudwatch#code-examples).
```
suspend fun deleteSubFilter(
filter: String?,
logGroup: String?,
) {
val request =
DeleteSubscriptionFilterRequest {
filterName = filter
logGroupName = logGroup
}
CloudWatchLogsClient.fromEnvironment { region = "us-west-2" }.use { logs ->
logs.deleteSubscriptionFilter(request)
println("Successfully deleted CloudWatch logs subscription filter named $filter")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteSubscriptionFilter](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `DescribeExportTasks` avec un AWS SDK
L'exemple de code suivant montre comment utiliser`DescribeExportTasks`.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/CloudWatchLogs#code-examples).
```
using System;
using System.Threading.Tasks;
using Amazon.CloudWatchLogs;
using Amazon.CloudWatchLogs.Model;
///
/// Shows how to retrieve a list of information about Amazon CloudWatch
/// Logs export tasks.
///
public class DescribeExportTasks
{
public static async Task Main()
{
// This client object will be associated with the same AWS Region
// as the default user on this system. If you need to use a
// different AWS Region, pass it as a parameter to the client
// constructor.
var client = new AmazonCloudWatchLogsClient();
var request = new DescribeExportTasksRequest
{
Limit = 5,
};
var response = new DescribeExportTasksResponse();
do
{
response = await client.DescribeExportTasksAsync(request);
response.ExportTasks.ForEach(t =>
{
Console.WriteLine($"{t.TaskName} with ID: {t.TaskId} has status: {t.Status}");
});
}
while (response.NextToken is not null);
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeExportTasks](https://docs.aws.amazon.com/goto/DotNetSDKV3/logs-2014-03-28/DescribeExportTasks)à la section *Référence des AWS SDK pour .NET API*.
------
# Utilisation `DescribeLogGroups` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeLogGroups`.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/CloudWatchLogs#code-examples).
```
using System;
using System.Threading.Tasks;
using Amazon.CloudWatchLogs;
using Amazon.CloudWatchLogs.Model;
///
/// Retrieves information about existing Amazon CloudWatch Logs log groups
/// and displays the information on the console.
///
public class DescribeLogGroups
{
public static async Task Main()
{
// Creates a CloudWatch Logs client using the default
// user. If you need to work with resources in another
// AWS Region than the one defined for the default user,
// pass the AWS Region as a parameter to the client constructor.
var client = new AmazonCloudWatchLogsClient();
bool done = false;
string newToken = null;
var request = new DescribeLogGroupsRequest
{
Limit = 5,
};
DescribeLogGroupsResponse response;
do
{
if (newToken is not null)
{
request.NextToken = newToken;
}
response = await client.DescribeLogGroupsAsync(request);
response.LogGroups.ForEach(lg =>
{
Console.WriteLine($"{lg.LogGroupName} is associated with the key: {lg.KmsKeyId}.");
Console.WriteLine($"Created on: {lg.CreationTime.Date.Date}");
Console.WriteLine($"Date for this group will be stored for: {lg.RetentionInDays} days.\n");
});
if (response.NextToken is null)
{
done = true;
}
else
{
newToken = response.NextToken;
}
}
while (!done);
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeLogGroups](https://docs.aws.amazon.com/goto/DotNetSDKV3/logs-2014-03-28/DescribeLogGroups)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ CLI ]
**AWS CLI**
La commande suivante décrit un groupe de journaux nommé `my-logs` :
```
aws logs describe-log-groups --log-group-name-prefix my-logs
```
Sortie :
```
{
"logGroups": [
{
"storedBytes": 0,
"metricFilterCount": 0,
"creationTime": 1433189500783,
"logGroupName": "my-logs",
"retentionInDays": 5,
"arn": "arn:aws:logs:us-west-2:0123456789012:log-group:my-logs:*"
}
]
}
```
+ Pour plus de détails sur l'API, voir [DescribeLogGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/logs/describe-log-groups.html)la section *Référence des AWS CLI commandes*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cloudwatch-logs#code-examples).
```
import {
paginateDescribeLogGroups,
CloudWatchLogsClient,
} from "@aws-sdk/client-cloudwatch-logs";
const client = new CloudWatchLogsClient({});
export const main = async () => {
const paginatedLogGroups = paginateDescribeLogGroups({ client }, {});
const logGroups = [];
for await (const page of paginatedLogGroups) {
if (page.logGroups?.every((lg) => !!lg)) {
logGroups.push(...page.logGroups);
}
}
console.log(logGroups);
return logGroups;
};
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeLogGroups](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DescribeLogGroupsCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
# Utilisation `DescribeLogStreams` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeLogStreams`.
------
#### [ CLI ]
**AWS CLI**
La commande suivante affiche tous les flux de journaux commençant par le préfixe `2015` dans le groupe de journaux `my-logs` :
```
aws logs describe-log-streams --log-group-name my-logs --log-stream-name-prefix 2015
```
Sortie :
```
{
"logStreams": [
{
"creationTime": 1433189871774,
"arn": "arn:aws:logs:us-west-2:0123456789012:log-group:my-logs:log-stream:20150531",
"logStreamName": "20150531",
"storedBytes": 0
},
{
"creationTime": 1433189873898,
"arn": "arn:aws:logs:us-west-2:0123456789012:log-group:my-logs:log-stream:20150601",
"logStreamName": "20150601",
"storedBytes": 0
}
]
}
```
+ Pour plus de détails sur l'API, voir [DescribeLogStreams](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/logs/describe-log-streams.html)la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/cloudwatch-logs#code-examples).
Recherche les flux de journaux au sein d'un groupe de journaux spécifié qui correspondent à un préfixe donné.
```
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CloudWatchLogsSearch {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
logGroupName - The name of the log group (for example, WeathertopJavaContainerLogs).
logStreamName - The name of the log stream (for example, weathertop-java-stream).
pattern - the pattern to use (for example, INFO)
""";
if (args.length != 3) {
System.out.print(usage);
System.exit(1);
}
String logGroupName = args[0] ;
String logStreamName = args[1] ;
String pattern = args[2] ;
CloudWatchLogsClient cwlClient = CloudWatchLogsClient.builder()
.region(Region.US_EAST_1)
.build();
searchLogStreamsAndFilterEvents(cwlClient, logGroupName, logStreamName, pattern);
}
/**
* Searches for log streams with a specific prefix within a log group and filters log events based on a specified pattern.
*
* @param cwlClient the CloudWatchLogsClient used to interact with AWS CloudWatch Logs
* @param logGroupName the name of the log group to search within
* @param logStreamPrefix the prefix of the log streams to search for
* @param pattern the pattern to filter log events by
*/
public static void searchLogStreamsAndFilterEvents(CloudWatchLogsClient cwlClient, String logGroupName, String logStreamPrefix, String pattern) {
DescribeLogStreamsRequest describeLogStreamsRequest = DescribeLogStreamsRequest.builder()
.logGroupName(logGroupName)
.logStreamNamePrefix(logStreamPrefix)
.build();
DescribeLogStreamsResponse describeLogStreamsResponse = cwlClient.describeLogStreams(describeLogStreamsRequest);
List logStreams = describeLogStreamsResponse.logStreams();
for (LogStream logStream : logStreams) {
String logStreamName = logStream.logStreamName();
System.out.println("Searching in log stream: " + logStreamName);
FilterLogEventsRequest filterLogEventsRequest = FilterLogEventsRequest.builder()
.logGroupName(logGroupName)
.logStreamNames(logStreamName)
.filterPattern(pattern)
.build();
FilterLogEventsResponse filterLogEventsResponse = cwlClient.filterLogEvents(filterLogEventsRequest);
for (FilteredLogEvent event : filterLogEventsResponse.events()) {
System.out.println(event.message());
}
System.out.println("--------------------------------------------------"); // Separator for better readability
}
}
}
```
Imprime les métadonnées relatives au flux de journaux le plus récent d'un groupe de journaux spécifié.
```
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CloudWatchLogQuery {
public static void main(final String[] args) {
final String usage = """
Usage:
Where:
logGroupName - The name of the log group (for example, /aws/lambda/ChatAIHandler).
""";
if (args.length != 1) {
System.out.print(usage);
System.exit(1);
}
String logGroupName = "/aws/lambda/ChatAIHandler" ; //args[0];
CloudWatchLogsClient logsClient = CloudWatchLogsClient.builder()
.region(Region.US_EAST_1)
.build();
describeMostRecentLogStream(logsClient, logGroupName);
}
/**
* Describes and prints metadata about the most recent log stream in the specified log group.
*
* @param logsClient the CloudWatchLogsClient used to interact with AWS CloudWatch Logs
* @param logGroupName the name of the log group
*/
public static void describeMostRecentLogStream(CloudWatchLogsClient logsClient, String logGroupName) {
DescribeLogStreamsRequest streamsRequest = DescribeLogStreamsRequest.builder()
.logGroupName(logGroupName)
.orderBy(OrderBy.LAST_EVENT_TIME)
.descending(true)
.limit(1)
.build();
try {
DescribeLogStreamsResponse streamsResponse = logsClient.describeLogStreams(streamsRequest);
List logStreams = streamsResponse.logStreams();
if (logStreams.isEmpty()) {
System.out.println("No log streams found for log group: " + logGroupName);
return;
}
LogStream stream = logStreams.get(0);
System.out.println("Most Recent Log Stream:");
System.out.println(" Name: " + stream.logStreamName());
System.out.println(" ARN: " + stream.arn());
System.out.println(" Creation Time: " + stream.creationTime());
System.out.println(" First Event Time: " + stream.firstEventTimestamp());
System.out.println(" Last Event Time: " + stream.lastEventTimestamp());
System.out.println(" Stored Bytes: " + stream.storedBytes());
System.out.println(" Upload Sequence Token: " + stream.uploadSequenceToken());
} catch (CloudWatchLogsException e) {
System.err.println("Failed to describe log stream: " + e.awsErrorDetails().errorMessage());
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeLogStreams](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/DescribeLogStreams)à la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DescribeSubscriptionFilters` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `DescribeSubscriptionFilters`.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch-logs#code-examples).
Joignez les fichiers requis.
```
#include
#include
#include
#include
#include
#include
#include
```
Répertoriez les filtres d’abonnement.
```
Aws::CloudWatchLogs::CloudWatchLogsClient cwl;
Aws::CloudWatchLogs::Model::DescribeSubscriptionFiltersRequest request;
request.SetLogGroupName(log_group);
request.SetLimit(1);
bool done = false;
bool header = false;
while (!done) {
auto outcome = cwl.DescribeSubscriptionFilters(
request);
if (!outcome.IsSuccess()) {
std::cout << "Failed to describe CloudWatch subscription filters "
<< "for log group " << log_group << ": " <<
outcome.GetError().GetMessage() << std::endl;
break;
}
if (!header) {
std::cout << std::left << std::setw(32) << "Name" <<
std::setw(64) << "FilterPattern" << std::setw(64) <<
"DestinationArn" << std::endl;
header = true;
}
const auto &filters = outcome.GetResult().GetSubscriptionFilters();
for (const auto &filter : filters) {
std::cout << std::left << std::setw(32) <<
filter.GetFilterName() << std::setw(64) <<
filter.GetFilterPattern() << std::setw(64) <<
filter.GetDestinationArn() << std::endl;
}
const auto &next_token = outcome.GetResult().GetNextToken();
request.SetNextToken(next_token);
done = next_token.empty();
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeSubscriptionFilters](https://docs.aws.amazon.com/goto/SdkForCpp/logs-2014-03-28/DescribeSubscriptionFilters)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/cloudwatch-logs#code-examples).
```
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;
import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient;
import software.amazon.awssdk.services.cloudwatchlogs.model.DescribeSubscriptionFiltersRequest;
import software.amazon.awssdk.services.cloudwatchlogs.model.DescribeSubscriptionFiltersResponse;
import software.amazon.awssdk.services.cloudwatchlogs.model.SubscriptionFilter;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DescribeSubscriptionFilters {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
logGroup - A log group name (for example, myloggroup).
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String logGroup = args[0];
CloudWatchLogsClient logs = CloudWatchLogsClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.build();
describeFilters(logs, logGroup);
logs.close();
}
public static void describeFilters(CloudWatchLogsClient logs, String logGroup) {
try {
boolean done = false;
String newToken = null;
while (!done) {
DescribeSubscriptionFiltersResponse response;
if (newToken == null) {
DescribeSubscriptionFiltersRequest request = DescribeSubscriptionFiltersRequest.builder()
.logGroupName(logGroup)
.limit(1).build();
response = logs.describeSubscriptionFilters(request);
} else {
DescribeSubscriptionFiltersRequest request = DescribeSubscriptionFiltersRequest.builder()
.nextToken(newToken)
.logGroupName(logGroup)
.limit(1).build();
response = logs.describeSubscriptionFilters(request);
}
for (SubscriptionFilter filter : response.subscriptionFilters()) {
System.out.printf("Retrieved filter with name %s, " + "pattern %s " + "and destination arn %s",
filter.filterName(),
filter.filterPattern(),
filter.destinationArn());
}
if (response.nextToken() == null) {
done = true;
} else {
newToken = response.nextToken();
}
}
} catch (CloudWatchException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
System.out.printf("Done");
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeSubscriptionFilters](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/DescribeSubscriptionFilters)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cloudwatch-logs#code-examples).
```
import { DescribeSubscriptionFiltersCommand } from "@aws-sdk/client-cloudwatch-logs";
import { client } from "../libs/client.js";
const run = async () => {
// This will return a list of all subscription filters in your account
// matching the log group name.
const command = new DescribeSubscriptionFiltersCommand({
logGroupName: process.env.CLOUDWATCH_LOGS_LOG_GROUP,
limit: 1,
});
try {
return await client.send(command);
} catch (err) {
console.error(err);
}
};
export default run();
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeSubscriptionFilters](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DescribeSubscriptionFiltersCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/cloudwatch-logs#code-examples).
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the CloudWatchLogs service object
var cwl = new AWS.CloudWatchLogs({ apiVersion: "2014-03-28" });
var params = {
logGroupName: "GROUP_NAME",
limit: 5,
};
cwl.describeSubscriptionFilters(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data.subscriptionFilters);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/cloudwatch-examples-subscriptions.html#cloudwatch-examples-subscriptions-describing).
+ Pour plus de détails sur l'API, reportez-vous [DescribeSubscriptionFilters](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/logs-2014-03-28/DescribeSubscriptionFilters)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/cloudwatch#code-examples).
```
suspend fun describeFilters(logGroup: String) {
val request =
DescribeSubscriptionFiltersRequest {
logGroupName = logGroup
limit = 1
}
CloudWatchLogsClient.fromEnvironment { region = "us-west-2" }.use { cwlClient ->
val response = cwlClient.describeSubscriptionFilters(request)
response.subscriptionFilters?.forEach { filter ->
println("Retrieved filter with name ${filter.filterName} pattern ${filter.filterPattern} and destination ${filter.destinationArn}")
}
}
}
```
+ Pour plus de détails sur l'API, consultez [DescribeSubscriptionFilters](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `GetLogEvents` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `GetLogEvents`.
------
#### [ CLI ]
**AWS CLI**
La commande suivante extrait les événements du journal à partir d’un flux de journaux nommé `20150601` dans le groupe de journaux `my-logs` :
```
aws logs get-log-events --log-group-name my-logs --log-stream-name 20150601
```
Sortie :
```
{
"nextForwardToken": "f/31961209122447488583055879464742346735121166569214640130",
"events": [
{
"ingestionTime": 1433190494190,
"timestamp": 1433190184356,
"message": "Example Event 1"
},
{
"ingestionTime": 1433190516679,
"timestamp": 1433190184356,
"message": "Example Event 1"
},
{
"ingestionTime": 1433190494190,
"timestamp": 1433190184358,
"message": "Example Event 2"
}
],
"nextBackwardToken": "b/31961209122358285602261756944988674324553373268216709120"
}
```
+ Pour plus de détails sur l'API, voir [GetLogEvents](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/logs/get-log-events.html)la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/cloudwatch#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.cloudwatch.model.CloudWatchException;
import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient;
import software.amazon.awssdk.services.cloudwatchlogs.model.DescribeLogStreamsRequest;
import software.amazon.awssdk.services.cloudwatchlogs.model.DescribeLogStreamsResponse;
import software.amazon.awssdk.services.cloudwatchlogs.model.GetLogEventsRequest;
import software.amazon.awssdk.services.cloudwatchlogs.model.GetLogEventsResponse;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class GetLogEvents {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
logGroupName - The name of the log group (for example, myloggroup).
logStreamName - The name of the log stream (for example, mystream).
""";
// if (args.length != 2) {
// System.out.print(usage);
// System.exit(1);
// }
String logGroupName = "WeathertopJavaContainerLogs" ; //args[0];
String logStreamName = "weathertop-java-stream" ; //args[1];
Region region = Region.US_EAST_1 ;
CloudWatchLogsClient cloudWatchLogsClient = CloudWatchLogsClient.builder()
.region(region)
.build();
getCWLogEvents(cloudWatchLogsClient, logGroupName, logStreamName);
cloudWatchLogsClient.close();
}
public static void getCWLogEvents(CloudWatchLogsClient cloudWatchLogsClient,
String logGroupName,
String logStreamPrefix) {
try {
// First, find the exact log stream name
DescribeLogStreamsRequest describeRequest = DescribeLogStreamsRequest.builder()
.logGroupName(logGroupName)
.logStreamNamePrefix(logStreamPrefix)
.limit(1) // get the first matching stream
.build();
DescribeLogStreamsResponse describeResponse = cloudWatchLogsClient.describeLogStreams(describeRequest);
if (describeResponse.logStreams().isEmpty()) {
System.out.println("No matching log streams found for prefix: " + logStreamPrefix);
return;
}
String exactLogStreamName = describeResponse.logStreams().get(0).logStreamName();
System.out.println("Using exact log stream: " + exactLogStreamName);
long startTime = Instant.now().minus(7, ChronoUnit.DAYS).toEpochMilli();
long endTime = Instant.now().toEpochMilli();
GetLogEventsRequest getLogEventsRequest = GetLogEventsRequest.builder()
.logGroupName(logGroupName)
.logStreamName(exactLogStreamName) // <-- exact name, not prefix
.startTime(startTime)
.endTime(endTime)
.startFromHead(true)
.build();
GetLogEventsResponse response = cloudWatchLogsClient.getLogEvents(getLogEventsRequest);
if (response.events().isEmpty()) {
System.out.println("No log events found in the past 7 days.");
} else {
response.events().forEach(e -> System.out.println(e.message()));
}
} catch (CloudWatchException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetLogEvents](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/GetLogEvents)à la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `GetQueryResults` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `GetQueryResults`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Exécution d’une requête volumineuse](cloudwatch-logs_example_cloudwatch-logs_Scenario_BigQuery_section.md)
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/CloudWatchLogs/LargeQuery#code-examples).
```
///
/// Gets the results of a CloudWatch Logs Insights query.
///
/// The ID of the query.
/// The query results response.
public async Task GetQueryResultsAsync(string queryId)
{
try
{
var request = new GetQueryResultsRequest
{
QueryId = queryId
};
var response = await _amazonCloudWatchLogs.GetQueryResultsAsync(request);
return response;
}
catch (ResourceNotFoundException ex)
{
_logger.LogError($"Query not found: {ex.Message}");
return null;
}
catch (Exception ex)
{
_logger.LogError($"An error occurred while getting query results: {ex.Message}");
return null;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetQueryResults](https://docs.aws.amazon.com/goto/DotNetSDKV4/logs-2014-03-28/GetQueryResults)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cloudwatch-logs#code-examples).
```
/**
* Simple wrapper for the GetQueryResultsCommand.
* @param {string} queryId
*/
_getQueryResults(queryId) {
return this.client.send(new GetQueryResultsCommand({ queryId }));
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetQueryResults](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/GetQueryResultsCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/cloudwatch-logs#code-examples).
```
def _wait_for_query_results(self, client, query_id):
"""
Waits for the query to complete and retrieves the results.
:param query_id: The ID of the initiated query.
:type query_id: str
:return: A list containing the results of the query.
:rtype: list
"""
while True:
time.sleep(1)
results = client.get_query_results(queryId=query_id)
if results["status"] in [
"Complete",
"Failed",
"Cancelled",
"Timeout",
"Unknown",
]:
return results.get("results", [])
```
+ Pour plus de détails sur l'API, consultez [GetQueryResults](https://docs.aws.amazon.com/goto/boto3/logs-2014-03-28/GetQueryResults)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/cwl#code-examples).
```
TRY.
oo_result = lo_cwl->getqueryresults(
iv_queryid = iv_query_id ).
" Display query status and result count
DATA(lv_status) = oo_result->get_status( ).
DATA(lt_results) = oo_result->get_results( ).
DATA(lv_result_count) = lines( lt_results ).
MESSAGE |Query status: { lv_status }. Retrieved { lv_result_count } log event(s).| TYPE 'I'.
CATCH /aws1/cx_cwlinvalidparameterex.
MESSAGE 'Invalid parameter.' TYPE 'E'.
CATCH /aws1/cx_cwlresourcenotfoundex.
MESSAGE 'Resource not found.' TYPE 'E'.
CATCH /aws1/cx_cwlserviceunavailex.
MESSAGE 'Service unavailable.' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [GetQueryResults](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Utilisation `PutSubscriptionFilter` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `PutSubscriptionFilter`.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch-logs#code-examples).
Joignez les fichiers requis.
```
#include
#include
#include
#include
#include
```
Créer le filtre d’abonnement
```
Aws::CloudWatchLogs::CloudWatchLogsClient cwl;
Aws::CloudWatchLogs::Model::PutSubscriptionFilterRequest request;
request.SetFilterName(filter_name);
request.SetFilterPattern(filter_pattern);
request.SetLogGroupName(log_group);
request.SetDestinationArn(dest_arn);
auto outcome = cwl.PutSubscriptionFilter(request);
if (!outcome.IsSuccess())
{
std::cout << "Failed to create CloudWatch logs subscription filter "
<< filter_name << ": " << outcome.GetError().GetMessage() <<
std::endl;
}
else
{
std::cout << "Successfully created CloudWatch logs subscription " <<
"filter " << filter_name << std::endl;
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutSubscriptionFilter](https://docs.aws.amazon.com/goto/SdkForCpp/logs-2014-03-28/PutSubscriptionFilter)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/cloudwatch-logs#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient;
import software.amazon.awssdk.services.cloudwatchlogs.model.CloudWatchLogsException;
import software.amazon.awssdk.services.cloudwatchlogs.model.PutSubscriptionFilterRequest;
/**
* Before running this code example, you need to grant permission to CloudWatch
* Logs the right to execute your Lambda function.
* To perform this task, you can use this CLI command:
*
* aws lambda add-permission --function-name "lamda1" --statement-id "lamda1"
* --principal "logs.us-west-2.amazonaws.com" --action "lambda:InvokeFunction"
* --source-arn "arn:aws:logs:us-west-2:111111111111:log-group:testgroup:*"
* --source-account "111111111111"
*
* Make sure you replace the function name with your function name and replace
* '111111111111' with your account details.
* For more information, see "Subscription Filters with AWS Lambda" in the
* Amazon CloudWatch Logs Guide.
*
*
* Also, before running this Java V2 code example,set up your development
* environment,including your credentials.
*
* For more information,see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
*/
public class PutSubscriptionFilter {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
filter - A filter name (for example, myfilter).
pattern - A filter pattern (for example, ERROR).
logGroup - A log group name (testgroup).
functionArn - An AWS Lambda function ARN (for example, arn:aws:lambda:us-west-2:111111111111:function:lambda1) .
""";
if (args.length != 4) {
System.out.println(usage);
System.exit(1);
}
String filter = args[0];
String pattern = args[1];
String logGroup = args[2];
String functionArn = args[3];
Region region = Region.US_WEST_2;
CloudWatchLogsClient cwl = CloudWatchLogsClient.builder()
.region(region)
.build();
putSubFilters(cwl, filter, pattern, logGroup, functionArn);
cwl.close();
}
public static void putSubFilters(CloudWatchLogsClient cwl,
String filter,
String pattern,
String logGroup,
String functionArn) {
try {
PutSubscriptionFilterRequest request = PutSubscriptionFilterRequest.builder()
.filterName(filter)
.filterPattern(pattern)
.logGroupName(logGroup)
.destinationArn(functionArn)
.build();
cwl.putSubscriptionFilter(request);
System.out.printf(
"Successfully created CloudWatch logs subscription filter %s",
filter);
} catch (CloudWatchLogsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutSubscriptionFilter](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/PutSubscriptionFilter)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cloudwatch-logs#code-examples).
```
import { PutSubscriptionFilterCommand } from "@aws-sdk/client-cloudwatch-logs";
import { client } from "../libs/client.js";
const run = async () => {
const command = new PutSubscriptionFilterCommand({
// An ARN of a same-account Kinesis stream, Kinesis Firehose
// delivery stream, or Lambda function.
// https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SubscriptionFilters.html
destinationArn: process.env.CLOUDWATCH_LOGS_DESTINATION_ARN,
// A name for the filter.
filterName: process.env.CLOUDWATCH_LOGS_FILTER_NAME,
// A filter pattern for subscribing to a filtered stream of log events.
// https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html
filterPattern: process.env.CLOUDWATCH_LOGS_FILTER_PATTERN,
// The name of the log group. Messages in this group matching the filter pattern
// will be sent to the destination ARN.
logGroupName: process.env.CLOUDWATCH_LOGS_LOG_GROUP,
});
try {
return await client.send(command);
} catch (err) {
console.error(err);
}
};
export default run();
```
+ Pour plus de détails sur l'API, reportez-vous [PutSubscriptionFilter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/PutSubscriptionFilterCommand)à la section *Référence des AWS SDK pour JavaScript API*.
**SDK pour JavaScript (v2)**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/cloudwatch-logs#code-examples).
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create the CloudWatchLogs service object
var cwl = new AWS.CloudWatchLogs({ apiVersion: "2014-03-28" });
var params = {
destinationArn: "LAMBDA_FUNCTION_ARN",
filterName: "FILTER_NAME",
filterPattern: "ERROR",
logGroupName: "LOG_GROUP",
};
cwl.putSubscriptionFilter(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data);
}
});
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/cloudwatch-examples-subscriptions.html#cloudwatch-examples-subscriptions-creating).
+ Pour plus de détails sur l'API, reportez-vous [PutSubscriptionFilter](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/logs-2014-03-28/PutSubscriptionFilter)à la section *Référence des AWS SDK pour JavaScript API*.
------
# Utilisation `StartLiveTail` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `StartLiveTail`.
------
#### [ .NET ]
**SDK pour .NET**
Joignez les fichiers requis.
```
using Amazon;
using Amazon.CloudWatchLogs;
using Amazon.CloudWatchLogs.Model;
```
Démarrez une session Live Tail.
```
var client = new AmazonCloudWatchLogsClient();
var request = new StartLiveTailRequest
{
LogGroupIdentifiers = logGroupIdentifiers,
LogStreamNames = logStreamNames,
LogEventFilterPattern = filterPattern,
};
var response = await client.StartLiveTailAsync(request);
// Catch if request fails
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
Console.WriteLine("Failed to start live tail session");
return;
}
```
Vous pouvez gérer les événements de la session Live Tail de deux manières :
```
/* Method 1
* 1). Asynchronously loop through the event stream
* 2). Set a timer to dispose the stream and stop the Live Tail session at the end.
*/
var eventStream = response.ResponseStream;
var task = Task.Run(() =>
{
foreach (var item in eventStream)
{
if (item is LiveTailSessionUpdate liveTailSessionUpdate)
{
foreach (var sessionResult in liveTailSessionUpdate.SessionResults)
{
Console.WriteLine("Message : {0}", sessionResult.Message);
}
}
if (item is LiveTailSessionStart)
{
Console.WriteLine("Live Tail session started");
}
// On-stream exceptions are processed here
if (item is CloudWatchLogsEventStreamException)
{
Console.WriteLine($"ERROR: {item}");
}
}
});
// Close the stream to stop the session after a timeout
if (!task.Wait(TimeSpan.FromSeconds(10))){
eventStream.Dispose();
Console.WriteLine("End of line");
}
```
```
/* Method 2
* 1). Add event handlers to each event variable
* 2). Start processing the stream and wait for a timeout using AutoResetEvent
*/
AutoResetEvent endEvent = new AutoResetEvent(false);
var eventStream = response.ResponseStream;
using (eventStream) // automatically disposes the stream to stop the session after execution finishes
{
eventStream.SessionStartReceived += (sender, e) =>
{
Console.WriteLine("LiveTail session started");
};
eventStream.SessionUpdateReceived += (sender, e) =>
{
foreach (LiveTailSessionLogEvent logEvent in e.EventStreamEvent.SessionResults){
Console.WriteLine("Message: {0}", logEvent.Message);
}
};
// On-stream exceptions are captured here
eventStream.ExceptionReceived += (sender, e) =>
{
Console.WriteLine($"ERROR: {e.EventStreamException.Message}");
};
eventStream.StartProcessing();
// Stream events for this amount of time.
endEvent.WaitOne(TimeSpan.FromSeconds(10));
Console.WriteLine("End of line");
}
```
+ Pour plus de détails sur l'API, reportez-vous [StartLiveTail](https://docs.aws.amazon.com/goto/DotNetSDKV3/logs-2014-03-28/StartLiveTail)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Joignez les fichiers requis.
```
import (
"context"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types"
)
```
Gérez les événements de la session Live Tail.
```
func handleEventStreamAsync(stream *cloudwatchlogs.StartLiveTailEventStream) {
eventsChan := stream.Events()
for {
event := <-eventsChan
switch e := event.(type) {
case *types.StartLiveTailResponseStreamMemberSessionStart:
log.Println("Received SessionStart event")
case *types.StartLiveTailResponseStreamMemberSessionUpdate:
for _, logEvent := range e.Value.SessionResults {
log.Println(*logEvent.Message)
}
default:
// Handle on-stream exceptions
if err := stream.Err(); err != nil {
log.Fatalf("Error occured during streaming: %v", err)
} else if event == nil {
log.Println("Stream is Closed")
return
} else {
log.Fatalf("Unknown event type: %T", e)
}
}
}
}
```
Démarrez une session Live Tail.
```
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error, " + err.Error())
}
client := cloudwatchlogs.NewFromConfig(cfg)
request := &cloudwatchlogs.StartLiveTailInput{
LogGroupIdentifiers: logGroupIdentifiers,
LogStreamNames: logStreamNames,
LogEventFilterPattern: logEventFilterPattern,
}
response, err := client.StartLiveTail(context.TODO(), request)
// Handle pre-stream Exceptions
if err != nil {
log.Fatalf("Failed to start streaming: %v", err)
}
// Start a Goroutine to handle events over stream
stream := response.GetStream()
go handleEventStreamAsync(stream)
```
Arrêtez la session Live Tail après un certain temps.
```
// Close the stream (which ends the session) after a timeout
time.Sleep(10 * time.Second)
stream.Close()
log.Println("Event stream closed")
```
+ Pour plus de détails sur l'API, reportez-vous [StartLiveTail](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs#Client.StartLiveTail)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Joignez les fichiers requis.
```
import io.reactivex.FlowableSubscriber;
import io.reactivex.annotations.NonNull;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsAsyncClient;
import software.amazon.awssdk.services.cloudwatchlogs.model.LiveTailSessionLogEvent;
import software.amazon.awssdk.services.cloudwatchlogs.model.LiveTailSessionStart;
import software.amazon.awssdk.services.cloudwatchlogs.model.LiveTailSessionUpdate;
import software.amazon.awssdk.services.cloudwatchlogs.model.StartLiveTailRequest;
import software.amazon.awssdk.services.cloudwatchlogs.model.StartLiveTailResponseHandler;
import software.amazon.awssdk.services.cloudwatchlogs.model.CloudWatchLogsException;
import software.amazon.awssdk.services.cloudwatchlogs.model.StartLiveTailResponseStream;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
```
Gérez les événements de la session Live Tail.
```
private static StartLiveTailResponseHandler getStartLiveTailResponseStreamHandler(
AtomicReference subscriptionAtomicReference) {
return StartLiveTailResponseHandler.builder()
.onResponse(r -> System.out.println("Received initial response"))
.onError(throwable -> {
CloudWatchLogsException e = (CloudWatchLogsException) throwable.getCause();
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
})
.subscriber(() -> new FlowableSubscriber<>() {
@Override
public void onSubscribe(@NonNull Subscription s) {
subscriptionAtomicReference.set(s);
s.request(Long.MAX_VALUE);
}
@Override
public void onNext(StartLiveTailResponseStream event) {
if (event instanceof LiveTailSessionStart) {
LiveTailSessionStart sessionStart = (LiveTailSessionStart) event;
System.out.println(sessionStart);
} else if (event instanceof LiveTailSessionUpdate) {
LiveTailSessionUpdate sessionUpdate = (LiveTailSessionUpdate) event;
List logEvents = sessionUpdate.sessionResults();
logEvents.forEach(e -> {
long timestamp = e.timestamp();
Date date = new Date(timestamp);
System.out.println("[" + date + "] " + e.message());
});
} else {
throw CloudWatchLogsException.builder().message("Unknown event type").build();
}
}
@Override
public void onError(Throwable throwable) {
System.out.println(throwable.getMessage());
System.exit(1);
}
@Override
public void onComplete() {
System.out.println("Completed Streaming Session");
}
})
.build();
}
```
Démarrez une session Live Tail.
```
CloudWatchLogsAsyncClient cloudWatchLogsAsyncClient =
CloudWatchLogsAsyncClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.build();
StartLiveTailRequest request =
StartLiveTailRequest.builder()
.logGroupIdentifiers(logGroupIdentifiers)
.logStreamNames(logStreamNames)
.logEventFilterPattern(logEventFilterPattern)
.build();
/* Create a reference to store the subscription */
final AtomicReference subscriptionAtomicReference = new AtomicReference<>(null);
cloudWatchLogsAsyncClient.startLiveTail(request, getStartLiveTailResponseStreamHandler(subscriptionAtomicReference));
```
Arrêtez la session Live Tail après un certain temps.
```
/* Set a timeout for the session and cancel the subscription. This will:
* 1). Close the stream
* 2). Stop the Live Tail session
*/
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (subscriptionAtomicReference.get() != null) {
subscriptionAtomicReference.get().cancel();
System.out.println("Subscription to stream closed");
}
```
+ Pour plus de détails sur l'API, reportez-vous [StartLiveTail](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/StartLiveTail)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Joignez les fichiers requis.
```
import { CloudWatchLogsClient, StartLiveTailCommand } from "@aws-sdk/client-cloudwatch-logs";
```
Gérez les événements de la session Live Tail.
```
async function handleResponseAsync(response) {
try {
for await (const event of response.responseStream) {
if (event.sessionStart !== undefined) {
console.log(event.sessionStart);
} else if (event.sessionUpdate !== undefined) {
for (const logEvent of event.sessionUpdate.sessionResults) {
const timestamp = logEvent.timestamp;
const date = new Date(timestamp);
console.log("[" + date + "] " + logEvent.message);
}
} else {
console.error("Unknown event type");
}
}
} catch (err) {
// On-stream exceptions are captured here
console.error(err)
}
}
```
Démarrez une session Live Tail.
```
const client = new CloudWatchLogsClient();
const command = new StartLiveTailCommand({
logGroupIdentifiers: logGroupIdentifiers,
logStreamNames: logStreamNames,
logEventFilterPattern: filterPattern
});
try{
const response = await client.send(command);
handleResponseAsync(response);
} catch (err){
// Pre-stream exceptions are captured here
console.log(err);
}
```
Arrêtez la session Live Tail après un certain temps.
```
/* Set a timeout to close the client. This will stop the Live Tail session. */
setTimeout(function() {
console.log("Client timeout");
client.destroy();
}, 10000);
```
+ Pour plus de détails sur l'API, reportez-vous [StartLiveTail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/StartLiveTailCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Joignez les fichiers requis.
```
import aws.sdk.kotlin.services.cloudwatchlogs.CloudWatchLogsClient
import aws.sdk.kotlin.services.cloudwatchlogs.model.StartLiveTailRequest
import aws.sdk.kotlin.services.cloudwatchlogs.model.StartLiveTailResponseStream
import kotlinx.coroutines.flow.takeWhile
```
Démarrez une session Live Tail.
```
val client = CloudWatchLogsClient.fromEnvironment()
val request = StartLiveTailRequest {
logGroupIdentifiers = logGroupIdentifiersVal
logStreamNames = logStreamNamesVal
logEventFilterPattern = logEventFilterPatternVal
}
val startTime = System.currentTimeMillis()
try {
client.startLiveTail(request) { response ->
val stream = response.responseStream
if (stream != null) {
/* Set a timeout to unsubcribe from the flow. This will:
* 1). Close the stream
* 2). Stop the Live Tail session
*/
stream.takeWhile { System.currentTimeMillis() - startTime < 10000 }.collect { value ->
if (value is StartLiveTailResponseStream.SessionStart) {
println(value.asSessionStart())
} else if (value is StartLiveTailResponseStream.SessionUpdate) {
for (e in value.asSessionUpdate().sessionResults!!) {
println(e)
}
} else {
throw IllegalArgumentException("Unknown event type")
}
}
} else {
throw IllegalArgumentException("No response stream")
}
}
} catch (e: Exception) {
println("Exception occurred during StartLiveTail: $e")
System.exit(1)
}
```
+ Pour plus de détails sur l'API, consultez [StartLiveTail](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Joignez les fichiers requis.
```
import boto3
import time
from datetime import datetime
```
Démarrez une session Live Tail.
```
# Initialize the client
client = boto3.client('logs')
start_time = time.time()
try:
response = client.start_live_tail(
logGroupIdentifiers=log_group_identifiers,
logStreamNames=log_streams,
logEventFilterPattern=filter_pattern
)
event_stream = response['responseStream']
# Handle the events streamed back in the response
for event in event_stream:
# Set a timeout to close the stream.
# This will end the Live Tail session.
if (time.time() - start_time >= 10):
event_stream.close()
break
# Handle when session is started
if 'sessionStart' in event:
session_start_event = event['sessionStart']
print(session_start_event)
# Handle when log event is given in a session update
elif 'sessionUpdate' in event:
log_events = event['sessionUpdate']['sessionResults']
for log_event in log_events:
print('[{date}] {log}'.format(date=datetime.fromtimestamp(log_event['timestamp']/1000),log=log_event['message']))
else:
# On-stream exceptions are captured here
raise RuntimeError(str(event))
except Exception as e:
print(e)
```
+ Pour plus de détails sur l'API, consultez [StartLiveTail](https://docs.aws.amazon.com/goto/boto3/logs-2014-03-28/StartLiveTail)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Utilisation `StartQuery` avec un AWS SDK
Les exemples de code suivants illustrent comment utiliser `StartQuery`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Exécution d’une requête volumineuse](cloudwatch-logs_example_cloudwatch-logs_Scenario_BigQuery_section.md)
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/CloudWatchLogs/LargeQuery#code-examples).
```
///
/// Starts a CloudWatch Logs Insights query.
///
/// The name of the log group to query.
/// The CloudWatch Logs Insights query string.
/// The start time for the query (seconds since epoch).
/// The end time for the query (seconds since epoch).
/// The maximum number of results to return.
/// The query ID if successful, null otherwise.
public async Task StartQueryAsync(
string logGroupName,
string queryString,
long startTime,
long endTime,
int limit = 10000)
{
try
{
var request = new StartQueryRequest
{
LogGroupName = logGroupName,
QueryString = queryString,
StartTime = startTime,
EndTime = endTime,
Limit = limit
};
var response = await _amazonCloudWatchLogs.StartQueryAsync(request);
return response.QueryId;
}
catch (InvalidParameterException ex)
{
_logger.LogError($"Invalid parameter for query: {ex.Message}");
return null;
}
catch (ResourceNotFoundException ex)
{
_logger.LogError($"Log group not found: {ex.Message}");
return null;
}
catch (Exception ex)
{
_logger.LogError($"An error occurred while starting query: {ex.Message}");
return null;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [StartQuery](https://docs.aws.amazon.com/goto/DotNetSDKV4/logs-2014-03-28/StartQuery)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cloudwatch-logs#code-examples).
```
/**
* Wrapper for the StartQueryCommand. Uses a static query string
* for consistency.
* @param {[Date, Date]} dateRange
* @param {number} maxLogs
* @returns {Promise<{ queryId: string }>}
*/
async _startQuery([startDate, endDate], maxLogs = 10000) {
try {
return await this.client.send(
new StartQueryCommand({
logGroupNames: this.logGroupNames,
queryString: "fields @timestamp, @message | sort @timestamp asc",
startTime: startDate.valueOf(),
endTime: endDate.valueOf(),
limit: maxLogs,
}),
);
} catch (err) {
/** @type {string} */
const message = err.message;
if (message.startsWith("Query's end date and time")) {
// This error indicates that the query's start or end date occur
// before the log group was created.
throw new DateOutOfBoundsError(message);
}
throw err;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [StartQuery](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/StartQueryCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/cloudwatch-logs#code-examples).
```
def perform_query(self, date_range):
"""
Performs the actual CloudWatch log query.
:param date_range: A tuple representing the start and end datetime for the query.
:type date_range: tuple
:return: A list containing the query results.
:rtype: list
"""
client = boto3.client("logs")
try:
try:
start_time = round(
self.date_utilities.convert_iso8601_to_unix_timestamp(date_range[0])
)
end_time = round(
self.date_utilities.convert_iso8601_to_unix_timestamp(date_range[1])
)
response = client.start_query(
logGroupName=self.log_group,
startTime=start_time,
endTime=end_time,
queryString=self.query_string,
limit=self.limit,
)
query_id = response["queryId"]
except client.exceptions.ResourceNotFoundException as e:
raise DateOutOfBoundsError(f"Resource not found: {e}")
while True:
time.sleep(1)
results = client.get_query_results(queryId=query_id)
if results["status"] in [
"Complete",
"Failed",
"Cancelled",
"Timeout",
"Unknown",
]:
return results.get("results", [])
except DateOutOfBoundsError:
return []
def _initiate_query(self, client, date_range, max_logs):
"""
Initiates the CloudWatch logs query.
:param date_range: A tuple representing the start and end datetime for the query.
:type date_range: tuple
:param max_logs: The maximum number of logs to retrieve.
:type max_logs: int
:return: The query ID as a string.
:rtype: str
"""
try:
start_time = round(
self.date_utilities.convert_iso8601_to_unix_timestamp(date_range[0])
)
end_time = round(
self.date_utilities.convert_iso8601_to_unix_timestamp(date_range[1])
)
response = client.start_query(
logGroupName=self.log_group,
startTime=start_time,
endTime=end_time,
queryString=self.query_string,
limit=max_logs,
)
return response["queryId"]
except client.exceptions.ResourceNotFoundException as e:
raise DateOutOfBoundsError(f"Resource not found: {e}")
```
+ Pour plus de détails sur l'API, consultez [StartQuery](https://docs.aws.amazon.com/goto/boto3/logs-2014-03-28/StartQuery)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/cwl#code-examples).
```
TRY.
" iv_log_group_name = '/aws/lambda/my-function'
" iv_query_string = 'fields @timestamp, @message | sort @timestamp desc | limit 20'
" iv_start_time and iv_end_time must be in Unix epoch milliseconds (ms since Jan 1, 1970 00:00:00 UTC)
oo_result = lo_cwl->startquery(
iv_loggroupname = iv_log_group_name
iv_starttime = iv_start_time
iv_endtime = iv_end_time
iv_querystring = iv_query_string
iv_limit = iv_limit ).
" Display the query ID for tracking
DATA(lv_query_id) = oo_result->get_queryid( ).
MESSAGE |Query started successfully with ID: { lv_query_id }| TYPE 'I'.
CATCH /aws1/cx_cwlinvalidparameterex.
MESSAGE 'Invalid parameter.' TYPE 'E'.
CATCH /aws1/cx_cwllimitexceededex.
MESSAGE 'Limit exceeded.' TYPE 'E'.
CATCH /aws1/cx_cwlmalformedqueryex.
MESSAGE 'Malformed query.' TYPE 'E'.
CATCH /aws1/cx_cwlresourcenotfoundex.
MESSAGE 'Resource not found.' TYPE 'E'.
CATCH /aws1/cx_cwlserviceunavailex.
MESSAGE 'Service unavailable.' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [StartQuery](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------