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);
}
}
}
```
+ Per i dettagli sull'API, consulta la [DeleteSubscriptionFilter](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/DeleteSubscriptionFilter)sezione *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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();
```
+ Per i dettagli sull'API, consulta la [DeleteSubscriptionFilter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DeleteSubscriptionFilterCommand)sezione *AWS SDK per JavaScript API Reference*.
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/cloudwatch-examples-subscriptions.html#cloudwatch-examples-subscriptions-deleting).
+ Per i dettagli sull'API, consulta la [DeleteSubscriptionFilter](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/logs-2014-03-28/DeleteSubscriptionFilter)sezione *AWS SDK per JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK per Kotlin**
C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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")
}
}
```
+ Per i dettagli sull'API, [DeleteSubscriptionFilter](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
------
# Utilizzare `DescribeExportTasks` con un SDK AWS
Il seguente esempio di codice mostra come utilizzare`DescribeExportTasks`.
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
}
```
+ Per i dettagli sull'API, consulta la [DescribeExportTasks](https://docs.aws.amazon.com/goto/DotNetSDKV3/logs-2014-03-28/DescribeExportTasks)sezione *AWS SDK per .NET API Reference*.
------
# Utilizzo `DescribeLogGroups` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeLogGroups`.
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
}
```
+ Per i dettagli sull'API, consulta la [DescribeLogGroups](https://docs.aws.amazon.com/goto/DotNetSDKV3/logs-2014-03-28/DescribeLogGroups)sezione *AWS SDK per .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente descrive un gruppo di log denominato `my-logs`.
```
aws logs describe-log-groups --log-group-name-prefix my-logs
```
Output:
```
{
"logGroups": [
{
"storedBytes": 0,
"metricFilterCount": 0,
"creationTime": 1433189500783,
"logGroupName": "my-logs",
"retentionInDays": 5,
"arn": "arn:aws:logs:us-west-2:0123456789012:log-group:my-logs:*"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLogGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/logs/describe-log-groups.html)*Command Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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;
};
```
+ Per i dettagli sull'API, consulta la [DescribeLogGroups](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DescribeLogGroupsCommand)sezione *AWS SDK per JavaScript API Reference*.
------
# Utilizzo `DescribeLogStreams` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeLogStreams`.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente mostra tutti i flussi di log che iniziano con il prefisso `2015` nel gruppo di log `my-logs`.
```
aws logs describe-log-streams --log-group-name my-logs --log-stream-name-prefix 2015
```
Output:
```
{
"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
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLogStreams AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/logs/describe-log-streams.html)*Command Reference.*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/cloudwatch-logs#code-examples).
Cerca i flussi di log all'interno di un gruppo di log specificato che corrispondono a un determinato prefisso.
```
/**
* 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
}
}
}
```
Stampa i metadati relativi al flusso di log più recente in un gruppo di log specificato.
```
/**
* 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());
}
}
}
```
+ Per i dettagli sull'API, consulta la sezione [DescribeLogStreams AWS SDK for Java 2.x](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/DescribeLogStreams)*API Reference.*
------
# Utilizzare `DescribeSubscriptionFilters` con un AWS SDK
Gli esempi di codice seguenti mostrano come utilizzare `DescribeSubscriptionFilters`.
------
#### [ C\$1\$1 ]
**SDK per C\$1\$1**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch-logs#code-examples).
Includere i file richiesti.
```
#include
#include
#include
#include
#include
#include
#include
```
Elencare i filtri di sottoscrizione.
```
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();
}
```
+ Per i dettagli sull'API, consulta la [DescribeSubscriptionFilters](https://docs.aws.amazon.com/goto/SdkForCpp/logs-2014-03-28/DescribeSubscriptionFilters)sezione *AWS SDK per C\$1\$1 API Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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");
}
}
```
+ Per i dettagli sull'API, consulta la [DescribeSubscriptionFilters](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/DescribeSubscriptionFilters)sezione *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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();
```
+ Per i dettagli sull'API, consulta la [DescribeSubscriptionFilters](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/DescribeSubscriptionFiltersCommand)sezione *AWS SDK per JavaScript API Reference*.
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/cloudwatch-examples-subscriptions.html#cloudwatch-examples-subscriptions-describing).
+ Per i dettagli sull'API, consulta la [DescribeSubscriptionFilters](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/logs-2014-03-28/DescribeSubscriptionFilters)sezione *AWS SDK per JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK per Kotlin**
C'è di più su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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}")
}
}
}
```
+ Per i dettagli sull'API, [DescribeSubscriptionFilters](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
------
# Utilizzo `GetLogEvents` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `GetLogEvents`.
------
#### [ CLI ]
**AWS CLI**
Il comando seguente recupera gli eventi del log da un flusso di log denominato `20150601` nel gruppo di log `my-logs`.
```
aws logs get-log-events --log-group-name my-logs --log-stream-name 20150601
```
Output:
```
{
"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"
}
```
+ Per i dettagli sull'API, consulta [GetLogEvents AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/logs/get-log-events.html)*Command Reference.*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
}
}
```
+ Per i dettagli sull'API, consulta la [GetLogEvents](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/GetLogEvents)sezione *AWS SDK for Java 2.x API Reference*.
------
# Utilizzare `GetQueryResults` con un AWS SDK
Gli esempi di codice seguenti mostrano come utilizzare `GetQueryResults`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Eseguire una query di grandi dimensioni](cloudwatch-logs_example_cloudwatch-logs_Scenario_BigQuery_section.md)
------
#### [ .NET ]
**SDK per .NET (v4)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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;
}
}
```
+ Per i dettagli sull'API, consulta la [GetQueryResults](https://docs.aws.amazon.com/goto/DotNetSDKV4/logs-2014-03-28/GetQueryResults)sezione *AWS SDK per .NET API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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 }));
}
```
+ Per i dettagli sull'API, consulta la [GetQueryResults](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/GetQueryResultsCommand)sezione *AWS SDK per JavaScript API Reference*.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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", [])
```
+ Per i dettagli sull'API, consulta [GetQueryResults AWS](https://docs.aws.amazon.com/goto/boto3/logs-2014-03-28/GetQueryResults)*SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK per SAP ABAP**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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.
```
+ Per i dettagli sulle API, [GetQueryResults](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)consulta *AWS SDK for SAP ABAP* API reference.
------
# Utilizzare `PutSubscriptionFilter` con un SDK AWS
Gli esempi di codice seguenti mostrano come utilizzare `PutSubscriptionFilter`.
------
#### [ C\$1\$1 ]
**SDK per C\$1\$1**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cloudwatch-logs#code-examples).
Includere i file richiesti.
```
#include
#include
#include
#include
#include
```
Creare il filtro di sottoscrizione.
```
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;
}
```
+ Per i dettagli sull'API, consulta la [PutSubscriptionFilter](https://docs.aws.amazon.com/goto/SdkForCpp/logs-2014-03-28/PutSubscriptionFilter)sezione *AWS SDK per C\$1\$1 API Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
}
}
```
+ Per i dettagli sull'API, consulta la [PutSubscriptionFilter](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/PutSubscriptionFilter)sezione *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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();
```
+ Per i dettagli sull'API, consulta la [PutSubscriptionFilter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/PutSubscriptionFilterCommand)sezione *AWS SDK per JavaScript API Reference*.
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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);
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/cloudwatch-examples-subscriptions.html#cloudwatch-examples-subscriptions-creating).
+ Per i dettagli sull'API, consulta la [PutSubscriptionFilter](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/logs-2014-03-28/PutSubscriptionFilter)sezione *AWS SDK per JavaScript API Reference*.
------
# Utilizzare `StartLiveTail` con un AWS SDK
Gli esempi di codice seguenti mostrano come utilizzare `StartLiveTail`.
------
#### [ .NET ]
**SDK per .NET**
Includere i file richiesti.
```
using Amazon;
using Amazon.CloudWatchLogs;
using Amazon.CloudWatchLogs.Model;
```
Avvia la sessione 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;
}
```
È possibile gestire gli eventi della sessione Live Tail in due modi.
```
/* 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");
}
```
+ Per i dettagli sull'API, consulta [StartLiveTail AWS SDK per .NET](https://docs.aws.amazon.com/goto/DotNetSDKV3/logs-2014-03-28/StartLiveTail)*API Reference.*
------
#### [ Go ]
**SDK per Go V2**
Includere i file richiesti.
```
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"
)
```
Gestisce gli eventi della sessione 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)
}
}
}
}
```
Avvia la sessione 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)
```
Arresta la sessione Live Tail dopo un determinato periodo di tempo.
```
// Close the stream (which ends the session) after a timeout
time.Sleep(10 * time.Second)
stream.Close()
log.Println("Event stream closed")
```
+ Per i dettagli sull'API, [StartLiveTail](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs#Client.StartLiveTail)consulta *AWS SDK per Go API Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
Includere i file richiesti.
```
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;
```
Gestisce gli eventi della sessione 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();
}
```
Avvia la sessione 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));
```
Arresta la sessione Live Tail dopo un determinato periodo di tempo.
```
/* 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");
}
```
+ Per i dettagli sull'API, [StartLiveTail](https://docs.aws.amazon.com/goto/SdkForJavaV2/logs-2014-03-28/StartLiveTail)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
Includere i file richiesti.
```
import { CloudWatchLogsClient, StartLiveTailCommand } from "@aws-sdk/client-cloudwatch-logs";
```
Gestisce gli eventi della sessione 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)
}
}
```
Avvia la sessione 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);
}
```
Arresta la sessione Live Tail dopo un determinato periodo di tempo.
```
/* Set a timeout to close the client. This will stop the Live Tail session. */
setTimeout(function() {
console.log("Client timeout");
client.destroy();
}, 10000);
```
+ Per i dettagli sull'API, consulta la sezione *AWS SDK per JavaScript API [StartLiveTail](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/StartLiveTailCommand)Reference*.
------
#### [ Kotlin ]
**SDK per Kotlin**
Includere i file richiesti.
```
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
```
Avvia la sessione 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)
}
```
+ Per i dettagli sull'API, consulta il riferimento [StartLiveTail](https://sdk.amazonaws.com/kotlin/api/latest/index.html)all'API *AWS SDK for Kotlin*.
------
#### [ Python ]
**SDK per Python (Boto3)**
Includere i file richiesti.
```
import boto3
import time
from datetime import datetime
```
Avvia la sessione 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)
```
+ Per i dettagli sull'API, consulta [StartLiveTail AWS](https://docs.aws.amazon.com/goto/boto3/logs-2014-03-28/StartLiveTail)*SDK for Python (Boto3) API Reference*.
------
# Utilizzare con un SDK `StartQuery` AWS
Gli esempi di codice seguenti mostrano come utilizzare `StartQuery`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Eseguire una query di grandi dimensioni](cloudwatch-logs_example_cloudwatch-logs_Scenario_BigQuery_section.md)
------
#### [ .NET ]
**SDK per .NET (v4)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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;
}
}
```
+ Per i dettagli sull'API, consulta la [StartQuery](https://docs.aws.amazon.com/goto/DotNetSDKV4/logs-2014-03-28/StartQuery)sezione *AWS SDK per .NET API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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;
}
}
```
+ Per i dettagli sull'API, consulta la [StartQuery](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/StartQueryCommand)sezione *AWS SDK per JavaScript API Reference*.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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}")
```
+ Per i dettagli sull'API, consulta [StartQuery AWS](https://docs.aws.amazon.com/goto/boto3/logs-2014-03-28/StartQuery)*SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK per SAP ABAP**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice 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.
```
+ Per i dettagli sulle API, [StartQuery](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)consulta *AWS SDK for SAP ABAP* API reference.
------