Container for the parameters to the PutMetricFilter operation. 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 PutLogEvents.

The maximum number of metric filters that can be associated with a log group is 100.

Inheritance: AmazonCloudWatchLogsRequest
Esempio n. 1
0
        public object Execute(ExecutorContext context)
        {
            var cmdletContext = context as CmdletContext;
            // create request
            var request = new Amazon.CloudWatchLogs.Model.PutMetricFilterRequest();

            if (cmdletContext.FilterName != null)
            {
                request.FilterName = cmdletContext.FilterName;
            }
            if (cmdletContext.FilterPattern != null)
            {
                request.FilterPattern = cmdletContext.FilterPattern;
            }
            if (cmdletContext.LogGroupName != null)
            {
                request.LogGroupName = cmdletContext.LogGroupName;
            }
            if (cmdletContext.MetricTransformation != null)
            {
                request.MetricTransformations = cmdletContext.MetricTransformation;
            }

            CmdletOutput output;

            // issue call
            var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);

            try
            {
                var    response       = CallAWSServiceOperation(client, request);
                object pipelineOutput = null;
                pipelineOutput = cmdletContext.Select(response, this);
                output         = new CmdletOutput
                {
                    PipelineOutput  = pipelineOutput,
                    ServiceResponse = response
                };
            }
            catch (Exception e)
            {
                output = new CmdletOutput {
                    ErrorResponse = e
                };
            }

            return(output);
        }
Esempio n. 2
0
 private Amazon.CloudWatchLogs.Model.PutMetricFilterResponse CallAWSServiceOperation(IAmazonCloudWatchLogs client, Amazon.CloudWatchLogs.Model.PutMetricFilterRequest request)
 {
     Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon CloudWatch Logs", "PutMetricFilter");
     try
     {
         #if DESKTOP
         return(client.PutMetricFilter(request));
         #elif CORECLR
         return(client.PutMetricFilterAsync(request).GetAwaiter().GetResult());
         #else
                 #error "Unknown build edition"
         #endif
     }
     catch (AmazonServiceException exc)
     {
         var webException = exc.InnerException as System.Net.WebException;
         if (webException != null)
         {
             throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
         }
         throw;
     }
 }
        /// <summary>
        /// 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 <code class="code">PutLogEvents</code> requests. 
        /// 
        ///  
        /// <para>
        ///  The maximum number of metric filters that can be associated with a log group is 100.
        /// 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the PutMetricFilter service method.</param>
        /// 
        /// <returns>The response from the PutMetricFilter service method, as returned by CloudWatchLogs.</returns>
        /// <exception cref="Amazon.CloudWatchLogs.Model.InvalidParameterException">
        /// Returned if a parameter of the request is incorrectly specified.
        /// </exception>
        /// <exception cref="Amazon.CloudWatchLogs.Model.LimitExceededException">
        /// Returned if you have reached the maximum number of resources that can be created.
        /// </exception>
        /// <exception cref="Amazon.CloudWatchLogs.Model.OperationAbortedException">
        /// Returned if multiple requests to update the same resource were in conflict.
        /// </exception>
        /// <exception cref="Amazon.CloudWatchLogs.Model.ResourceNotFoundException">
        /// Returned if the specified resource does not exist.
        /// </exception>
        /// <exception cref="Amazon.CloudWatchLogs.Model.ServiceUnavailableException">
        /// Returned if the service cannot complete the request.
        /// </exception>
        public PutMetricFilterResponse PutMetricFilter(PutMetricFilterRequest request)
        {
            var marshaller = new PutMetricFilterRequestMarshaller();
            var unmarshaller = PutMetricFilterResponseUnmarshaller.Instance;

            return Invoke<PutMetricFilterRequest,PutMetricFilterResponse>(request, marshaller, unmarshaller);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the PutMetricFilter operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the PutMetricFilter operation.</param>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public Task<PutMetricFilterResponse> PutMetricFilterAsync(PutMetricFilterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new PutMetricFilterRequestMarshaller();
            var unmarshaller = PutMetricFilterResponseUnmarshaller.Instance;

            return InvokeAsync<PutMetricFilterRequest,PutMetricFilterResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the PutMetricFilter operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the PutMetricFilter operation on AmazonCloudWatchLogsClient.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutMetricFilter
        ///         operation.</returns>
        public IAsyncResult BeginPutMetricFilter(PutMetricFilterRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new PutMetricFilterRequestMarshaller();
            var unmarshaller = PutMetricFilterResponseUnmarshaller.Instance;

            return BeginInvoke<PutMetricFilterRequest>(request, marshaller, unmarshaller,
                callback, state);
        }
        IAsyncResult invokePutMetricFilter(PutMetricFilterRequest request, AsyncCallback callback, object state, bool synchronized)
        {
            var marshaller = new PutMetricFilterRequestMarshaller();
            var unmarshaller = PutMetricFilterResponseUnmarshaller.Instance;

            return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
        }
 /// <summary>
 /// Initiates the asynchronous execution of the PutMetricFilter operation.
 /// <seealso cref="Amazon.CloudWatchLogs.IAmazonCloudWatchLogs"/>
 /// </summary>
 /// 
 /// <param name="request">Container for the necessary parameters to execute the PutMetricFilter operation on AmazonCloudWatchLogsClient.</param>
 /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
 /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
 ///          procedure using the AsyncState property.</param>
 /// 
 /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPutMetricFilter
 ///         operation.</returns>
 public IAsyncResult BeginPutMetricFilter(PutMetricFilterRequest request, AsyncCallback callback, object state)
 {
     return invokePutMetricFilter(request, callback, state, false);
 }
 /// <summary>
 /// 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 <code class="code">PutLogEvents</code> requests.
 /// </summary>
 /// <param name="request">Container for the necessary parameters to execute the PutMetricFilter service method.</param>
 /// 
 /// <returns>The response from the PutMetricFilter service method, as returned by CloudWatchLogs.</returns>
 /// <exception cref="InvalidParameterException">
 /// Returned if a parameter of the request is incorrectly specified.
 /// </exception>
 /// <exception cref="LimitExceededException">
 /// Returned if you have reached the maximum number of resources that can be created.
 /// </exception>
 /// <exception cref="OperationAbortedException">
 /// Returned if multiple requests to update the same resource were in conflict.
 /// </exception>
 /// <exception cref="ResourceNotFoundException">
 /// Returned if the specified resource does not exist.
 /// </exception>
 /// <exception cref="ServiceUnavailableException">
 /// Returned if the service cannot complete the request.
 /// </exception>
 public PutMetricFilterResponse PutMetricFilter(PutMetricFilterRequest request)
 {
     IAsyncResult asyncResult = invokePutMetricFilter(request, null, null, true);
     return EndPutMetricFilter(asyncResult);
 }
 /// <summary>
 /// 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 <code class="code">PutLogEvents</code> requests.
 /// </summary>
 /// <param name="request">Container for the necessary parameters to execute the PutMetricFilter service method.</param>
 /// 
 /// <returns>The response from the PutMetricFilter service method, as returned by CloudWatchLogs.</returns>
 /// <exception cref="InvalidParameterException">
 /// Returned if a parameter of the request is incorrectly specified.
 /// </exception>
 /// <exception cref="LimitExceededException">
 /// Returned if you have reached the maximum number of resources that can be created.
 /// </exception>
 /// <exception cref="OperationAbortedException">
 /// Returned if multiple requests to update the same resource were in conflict.
 /// </exception>
 /// <exception cref="ResourceNotFoundException">
 /// Returned if the specified resource does not exist.
 /// </exception>
 /// <exception cref="ServiceUnavailableException">
 /// Returned if the service cannot complete the request.
 /// </exception>
 public PutMetricFilterResponse PutMetricFilter(PutMetricFilterRequest request)
 {
     var task = PutMetricFilterAsync(request);
     try
     {
         return task.Result;
     }
     catch(AggregateException e)
     {
         ExceptionDispatchInfo.Capture(e.InnerException).Throw();
         return null;
     }
 }