@aws-sdk/client-cloudwatch-logs 3.34.0 → 3.35.0

package/src/commands/GetQueryResultsCommand.ts

@@ -0,0 +1,105 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { GetQueryResultsRequest, GetQueryResultsResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1GetQueryResultsCommand,
+  serializeAws_json1_1GetQueryResultsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface GetQueryResultsCommandInput extends GetQueryResultsRequest {}
+export interface GetQueryResultsCommandOutput extends GetQueryResultsResponse, __MetadataBearer {}
+
+/**
+ * <p>Returns the results from the specified query.</p>
+ *          <p>Only the fields requested in the query are returned, along with a <code>@ptr</code>
+ *       field, which is the identifier for the log record. You can use the value of <code>@ptr</code>
+ *       in a <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogRecord.html">GetLogRecord</a>
+ *       operation to get the full log record.</p>
+ *          <p>
+ *             <code>GetQueryResults</code>
+ *       does not start a query execution. To run a query, use <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html">StartQuery</a>.</p>
+ *          <p>If the value of the <code>Status</code> field in the output is <code>Running</code>, this operation
+ *       returns only partial results. If you see a value of <code>Scheduled</code> or <code>Running</code> for the status,
+ *       you can retry the operation later to see the final results. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, GetQueryResultsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, GetQueryResultsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new GetQueryResultsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetQueryResultsCommandInput} for command's `input` shape.
+ * @see {@link GetQueryResultsCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class GetQueryResultsCommand extends $Command<
+  GetQueryResultsCommandInput,
+  GetQueryResultsCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: GetQueryResultsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<GetQueryResultsCommandInput, GetQueryResultsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "GetQueryResultsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: GetQueryResultsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: GetQueryResultsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: GetQueryResultsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1GetQueryResultsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<GetQueryResultsCommandOutput> {
+    return deserializeAws_json1_1GetQueryResultsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/ListTagsLogGroupCommand.ts

@@ -0,0 +1,95 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { ListTagsLogGroupRequest, ListTagsLogGroupResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1ListTagsLogGroupCommand,
+  serializeAws_json1_1ListTagsLogGroupCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface ListTagsLogGroupCommandInput extends ListTagsLogGroupRequest {}
+export interface ListTagsLogGroupCommandOutput extends ListTagsLogGroupResponse, __MetadataBearer {}
+
+/**
+ * <p>Lists the tags for the specified log group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, ListTagsLogGroupCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, ListTagsLogGroupCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new ListTagsLogGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsLogGroupCommandInput} for command's `input` shape.
+ * @see {@link ListTagsLogGroupCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class ListTagsLogGroupCommand extends $Command<
+  ListTagsLogGroupCommandInput,
+  ListTagsLogGroupCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: ListTagsLogGroupCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<ListTagsLogGroupCommandInput, ListTagsLogGroupCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "ListTagsLogGroupCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: ListTagsLogGroupRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: ListTagsLogGroupResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: ListTagsLogGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1ListTagsLogGroupCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ListTagsLogGroupCommandOutput> {
+    return deserializeAws_json1_1ListTagsLogGroupCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutDestinationCommand.ts

@@ -0,0 +1,104 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutDestinationRequest, PutDestinationResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutDestinationCommand,
+  serializeAws_json1_1PutDestinationCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutDestinationCommandInput extends PutDestinationRequest {}
+export interface PutDestinationCommandOutput extends PutDestinationResponse, __MetadataBearer {}
+
+/**
+ * <p>Creates or updates a destination. This operation is used only to create destinations for cross-account subscriptions.</p>
+ *          <p>A destination encapsulates a physical resource (such
+ *       as an Amazon Kinesis stream) and enables you to subscribe to a real-time stream of log events
+ *       for a different account, ingested using <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a>.</p>
+ *          <p>Through an access policy, a destination controls what is written to it.
+ *       By default, <code>PutDestination</code> does not set any access policy with the destination,
+ *       which means a cross-account user cannot call <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutSubscriptionFilter.html">PutSubscriptionFilter</a> against
+ *       this destination. To enable this, the destination owner must call <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutDestinationPolicy.html">PutDestinationPolicy</a> after <code>PutDestination</code>.</p>
+ *          <p>To perform a <code>PutDestination</code> operation, you must also have the
+ *     <code>iam:PassRole</code> permission.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutDestinationCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutDestinationCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutDestinationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutDestinationCommandInput} for command's `input` shape.
+ * @see {@link PutDestinationCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutDestinationCommand extends $Command<
+  PutDestinationCommandInput,
+  PutDestinationCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutDestinationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutDestinationCommandInput, PutDestinationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutDestinationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutDestinationRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PutDestinationResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutDestinationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutDestinationCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutDestinationCommandOutput> {
+    return deserializeAws_json1_1PutDestinationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutDestinationPolicyCommand.ts

@@ -0,0 +1,100 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutDestinationPolicyRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutDestinationPolicyCommand,
+  serializeAws_json1_1PutDestinationPolicyCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutDestinationPolicyCommandInput extends PutDestinationPolicyRequest {}
+export interface PutDestinationPolicyCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Creates or updates an access policy associated with an existing
+ *       destination. An access policy is an <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html">IAM policy document</a> that is used
+ *       to authorize claims to register a subscription filter against a given destination.</p>
+ *          <p>If multiple Amazon Web Services accounts are sending logs to this destination, each sender account must be
+ *     listed separately in the policy. The policy does not support specifying <code>*</code>
+ *     as the Principal or the use of the <code>aws:PrincipalOrgId</code> global key.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutDestinationPolicyCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutDestinationPolicyCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutDestinationPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutDestinationPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutDestinationPolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutDestinationPolicyCommand extends $Command<
+  PutDestinationPolicyCommandInput,
+  PutDestinationPolicyCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutDestinationPolicyCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutDestinationPolicyCommandInput, PutDestinationPolicyCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutDestinationPolicyCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutDestinationPolicyRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutDestinationPolicyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutDestinationPolicyCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutDestinationPolicyCommandOutput> {
+    return deserializeAws_json1_1PutDestinationPolicyCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutLogEventsCommand.ts

@@ -0,0 +1,132 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutLogEventsRequest, PutLogEventsResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutLogEventsCommand,
+  serializeAws_json1_1PutLogEventsCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutLogEventsCommandInput extends PutLogEventsRequest {}
+export interface PutLogEventsCommandOutput extends PutLogEventsResponse, __MetadataBearer {}
+
+/**
+ * <p>Uploads a batch of log events to the specified log stream.</p>
+ *          <p>You must include the sequence token obtained from the response of the previous call. An
+ *       upload in a newly created log stream does not require a sequence token. You can also get the
+ *       sequence token in the <code>expectedSequenceToken</code> field from
+ *         <code>InvalidSequenceTokenException</code>. If you call <code>PutLogEvents</code> twice
+ *       within a narrow time period using the same value for <code>sequenceToken</code>, both calls
+ *       might be successful or one might be rejected.</p>
+ *          <p>The batch of events must satisfy the following constraints:</p>
+ *          <ul>
+ *             <li>
+ *                <p>The maximum batch size is 1,048,576 bytes. This size is calculated as the sum of
+ *           all event messages in UTF-8, plus 26 bytes for each log event.</p>
+ *             </li>
+ *             <li>
+ *                <p>None of the log events in the batch can be more than 2 hours in the future.</p>
+ *             </li>
+ *             <li>
+ *                <p>None of the log events in the batch can be older than 14 days or older than the retention
+ *           period of the log group.</p>
+ *             </li>
+ *             <li>
+ *                <p>The log events in the batch must be in chronological order by their timestamp. The
+ *           timestamp is the time the event occurred, expressed as the number of milliseconds after
+ *           Jan 1, 1970 00:00:00 UTC. (In Amazon Web Services Tools for PowerShell and the Amazon Web Services SDK for .NET, the
+ *           timestamp is specified in .NET format: yyyy-mm-ddThh:mm:ss. For example,
+ *           2017-09-15T13:45:30.) </p>
+ *             </li>
+ *             <li>
+ *                <p>A batch of log events in a single request cannot span more than 24 hours. Otherwise, the operation fails.</p>
+ *             </li>
+ *             <li>
+ *                <p>The maximum number of log events in a batch is 10,000.</p>
+ *             </li>
+ *             <li>
+ *                <p>There is a quota of 5 requests per second per log stream. Additional requests are throttled. This quota can't be changed.</p>
+ *             </li>
+ *          </ul>
+ *          <p>If a call to <code>PutLogEvents</code> returns "UnrecognizedClientException" the most likely cause is an invalid Amazon Web Services access key ID or secret key. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutLogEventsCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutLogEventsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutLogEventsCommandInput} for command's `input` shape.
+ * @see {@link PutLogEventsCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutLogEventsCommand extends $Command<
+  PutLogEventsCommandInput,
+  PutLogEventsCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutLogEventsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutLogEventsCommandInput, PutLogEventsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutLogEventsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutLogEventsRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: PutLogEventsResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutLogEventsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutLogEventsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutLogEventsCommandOutput> {
+    return deserializeAws_json1_1PutLogEventsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/PutMetricFilterCommand.ts

@@ -0,0 +1,117 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CloudWatchLogsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudWatchLogsClient";
+import { PutMetricFilterRequest } from "../models/models_0";
+import {
+  deserializeAws_json1_1PutMetricFilterCommand,
+  serializeAws_json1_1PutMetricFilterCommand,
+} from "../protocols/Aws_json1_1";
+
+export interface PutMetricFilterCommandInput extends PutMetricFilterRequest {}
+export interface PutMetricFilterCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Creates or updates a metric filter and associates it with the specified log group.
+ *       Metric filters allow you to configure rules to extract metric data from log events ingested
+ *       through <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html">PutLogEvents</a>.</p>
+ *          <p>The maximum number of metric filters that can be associated with a log group is
+ *       100.</p>
+ *          <p>When you create a metric filter, you can also optionally assign a unit and dimensions
+ *     to the metric that is created.</p>
+ *          <important>
+ *             <p>Metrics extracted from log events are charged as custom metrics.
+ *       To prevent unexpected high charges, do not specify high-cardinality fields such as
+ *       <code>IPAddress</code> or <code>requestID</code> as dimensions. Each different value
+ *       found for
+ *       a dimension is treated as a separate metric and accrues charges as a separate custom metric.
+ *     </p>
+ *             <p>To help prevent accidental high charges, Amazon disables a metric filter
+ *         if it generates 1000 different name/value pairs for the dimensions that you
+ *         have specified within a certain amount of time.</p>
+ *             <p>You can also set up a billing alarm to alert you if your charges are higher than
+ *         expected. For more information,
+ *         see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html">
+ *           Creating a Billing Alarm to Monitor Your Estimated Amazon Web Services Charges</a>.
+ *       </p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudWatchLogsClient, PutMetricFilterCommand } from "@aws-sdk/client-cloudwatch-logs"; // ES Modules import
+ * // const { CloudWatchLogsClient, PutMetricFilterCommand } = require("@aws-sdk/client-cloudwatch-logs"); // CommonJS import
+ * const client = new CloudWatchLogsClient(config);
+ * const command = new PutMetricFilterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutMetricFilterCommandInput} for command's `input` shape.
+ * @see {@link PutMetricFilterCommandOutput} for command's `response` shape.
+ * @see {@link CloudWatchLogsClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class PutMetricFilterCommand extends $Command<
+  PutMetricFilterCommandInput,
+  PutMetricFilterCommandOutput,
+  CloudWatchLogsClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: PutMetricFilterCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: CloudWatchLogsClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<PutMetricFilterCommandInput, PutMetricFilterCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "CloudWatchLogsClient";
+    const commandName = "PutMetricFilterCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: PutMetricFilterRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: PutMetricFilterCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1PutMetricFilterCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutMetricFilterCommandOutput> {
+    return deserializeAws_json1_1PutMetricFilterCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}