protected virtual async Task GetSequenceTokenAsync(string logStreamName, bool createStreamIfNotExists) { // Failover if (_failoverSinkEnabled) { // Failover to Secondary Region _ = FailOverToSecondaryRegion(_throttle); } try { var request = new DescribeLogStreamsRequest { LogGroupName = _logGroupName, LogStreamNamePrefix = logStreamName }; DescribeLogStreamsResponse describeLogsStreamsResponse = null; try { describeLogsStreamsResponse = await CloudWatchLogsClient.DescribeLogStreamsAsync(request); } catch (ResourceNotFoundException rex) { // Create the log group if it doesn't exist. if (rex.Message.IndexOf("log group does not exist") > -1) { _logger?.LogInformation("Log group {0} does not exist. Creating it.", _logGroupName); await CreateLogGroupAsync(); if (createStreamIfNotExists) { await CreateLogStreamAsync(logStreamName); } return; } } var logStream = describeLogsStreamsResponse.LogStreams .FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase)); if (logStream == null) { if (createStreamIfNotExists) { await CreateLogStreamAsync(logStreamName); } } else { _sequenceToken = logStream.UploadSequenceToken; } } catch (Exception) { // Set error count _throttle.SetError(); throw; } }
/// <summary> /// Initiates the asynchronous execution of the DescribeLogStreams operation. /// <seealso cref="Amazon.CloudWatchLogs.IAmazonCloudWatchLogs"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DescribeLogStreams 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 <DescribeLogStreamsResponse> DescribeLogStreamsAsync(DescribeLogStreamsRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DescribeLogStreamsRequestMarshaller(); var unmarshaller = DescribeLogStreamsResponseUnmarshaller.Instance; return(Invoke <IRequest, DescribeLogStreamsRequest, DescribeLogStreamsResponse>(request, marshaller, unmarshaller, signer, cancellationToken)); }
public async Task DeleteCloudWatchLogStreamsForLogStreams(string logGroupName) { try { var client = new AmazonCloudWatchLogsClient(AwsCredentials, Region); var logStreamRequest = new DescribeLogStreamsRequest() { LogGroupName = logGroupName, OrderBy = OrderBy.LastEventTime }; var logStreamsResponse = await client.DescribeLogStreamsAsync(logStreamRequest); // rate limit is 5 per second foreach (var stream in logStreamsResponse.LogStreams) { var request = new DeleteLogStreamRequest(logGroupName, stream.LogStreamName); var deleteLogStringresponse = await client.DeleteLogStreamAsync(request); Thread.Sleep(150); } } catch (Exception ex) { throw ex; } }
private async void PutLog(string groupName, string streamName, string msg) { try { var req = new DescribeLogStreamsRequest(groupName) { LogStreamNamePrefix = streamName }; var resp = await _logsClient.DescribeLogStreamsAsync(req); var token = resp.LogStreams.FirstOrDefault(s => s.LogStreamName == streamName)?.UploadSequenceToken; var ie = new InputLogEvent { Message = msg, Timestamp = DateTime.UtcNow }; var request = new PutLogEventsRequest(groupName, streamName, new List <InputLogEvent> { ie }); if (!string.IsNullOrEmpty(token)) { request.SequenceToken = token; } await _logsClient.PutLogEventsAsync(request); } catch (Exception e) { // ignored } }
public async Task DescribeLogStreamsTest_TwoResponses() { var request = new DescribeLogStreamsRequest(); var firstResponse = new DescribeLogStreamsResponse() { NextToken = "foo" }; var secondResponse = new DescribeLogStreamsResponse() { NextToken = null }; var token = new CancellationToken(); _mockClient.SetupSequence(x => x.DescribeLogStreamsAsync(It.IsAny <DescribeLogStreamsRequest>(), It.IsAny <CancellationToken>())) .ReturnsAsync(firstResponse) .ReturnsAsync(secondResponse); var numResponses = 0; await foreach (var desination in _mockClient.Object.Paginators.DescribeLogStreams(request).Responses.WithCancellation(token)) { numResponses += 1; } Assert.Equal(2, numResponses); }
internal DescribeLogStreamsResponse DescribeLogStreams(DescribeLogStreamsRequest request) { var marshaller = new DescribeLogStreamsRequestMarshaller(); var unmarshaller = DescribeLogStreamsResponseUnmarshaller.Instance; return(Invoke <DescribeLogStreamsRequest, DescribeLogStreamsResponse>(request, marshaller, unmarshaller)); }
public async Task <List <string> > GetCloudWatchEventMessagesForLogGroup(string logGroupName, DateTime startTime) { var result = new List <string>(); var stopWatch = new Stopwatch(); try { var client = new AmazonCloudWatchLogsClient(AwsCredentials, Region); var logStreamRequest = new DescribeLogStreamsRequest() { LogGroupName = logGroupName, OrderBy = OrderBy.LastEventTime }; stopWatch.Start(); while (stopWatch.ElapsedMilliseconds < TimeSpan.FromMinutes(1).TotalMilliseconds) { var logStreamsResponse = await client.DescribeLogStreamsAsync(logStreamRequest); // rate limit is 5 per second foreach (var stream in logStreamsResponse.LogStreams) { var logEventsRequest = new GetLogEventsRequest() { LogGroupName = logGroupName, LogStreamName = stream.LogStreamName, StartTime = startTime, }; var logEventsResponse = await client.GetLogEventsAsync(logEventsRequest); // rate limit is 10 per second result.AddRange(logEventsResponse.Events.Select(e => e.Message).ToList()); Thread.Sleep(150); } if (result.Count > 0) { var nrLog = result.Where(l => l.Contains(NRLogIdentifier)); if (nrLog?.Count() > 0) { break; } } Thread.Sleep(250); } } catch (Exception e) { throw e; } stopWatch.Stop(); return(result); }
/// <summary> /// Updates the log stream sequence token. /// </summary> /// <exception cref="Serilog.Sinks.AwsCloudWatch.AwsCloudWatchSinkException"></exception> private async Task UpdateLogStreamSequenceTokenAsync() { DescribeLogStreamsRequest describeLogStreamsRequest = new DescribeLogStreamsRequest { LogGroupName = options.LogGroupName, LogStreamNamePrefix = logStreamName }; var describeLogStreamsResponse = await cloudWatchClient.DescribeLogStreamsAsync(describeLogStreamsRequest); nextSequenceToken = describeLogStreamsResponse.NextToken; }
private async Task <string> GetLatestLogStream(string logGroup) { var request = new DescribeLogStreamsRequest { LogGroupName = logGroup }; var response = await _client.DescribeLogStreamsAsync(request); return(response.LogStreams.FirstOrDefault()?.LogStreamName); }
internal DescribeLogStreamsResponse DescribeLogStreams(DescribeLogStreamsRequest request) { var task = DescribeLogStreamsAsync(request); try { return(task.Result); } catch (AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return(null); } }
public async Task DescribeLogStreamsTest__OnlyUsedOnce() { var request = new DescribeLogStreamsRequest(); var response = new DescribeLogStreamsResponse(); var token = new CancellationToken(); var paginator = _mockClient.Object.Paginators.DescribeLogStreams(request); _mockClient.Setup(x => x.DescribeLogStreamsAsync(It.IsAny <DescribeLogStreamsRequest>(), It.IsAny <CancellationToken>())).ReturnsAsync(response); // Should work the first time await LoopOverLogStreams(paginator, token); // Second time should throw an exception await Assert.ThrowsAsync <System.InvalidOperationException>(async() => await LoopOverLogStreams(paginator, token)); }
/// <summary> /// Attempts to get the log stream defined by <see cref="logStreamName"/>. /// </summary> /// <returns>The matching log stream or null if no match can be found.</returns> private async Task <LogStream> GetLogStreamAsync() { var describeLogStreamsRequest = new DescribeLogStreamsRequest { LogGroupName = options.LogGroupName, LogStreamNamePrefix = logStreamName }; var describeLogStreamsResponse = await cloudWatchClient .DescribeLogStreamsAsync(describeLogStreamsRequest); return(describeLogStreamsResponse .LogStreams .SingleOrDefault(ls => string.Equals(ls.LogStreamName, logStreamName, StringComparison.Ordinal))); }
private async Task GetSequenceTokenAsync(string logStreamName, bool createStreamIfNotExists) { var request = new DescribeLogStreamsRequest { LogGroupName = _logGroupName, LogStreamNamePrefix = logStreamName }; DescribeLogStreamsResponse describeLogsStreamsResponse = null; try { describeLogsStreamsResponse = await _client.DescribeLogStreamsAsync(request); } catch (ResourceNotFoundException rex) { // Create the log group if it doesn't exist. if (rex.Message.IndexOf("log group does not exist") > -1) { _logger?.LogInformation("Log group {0} does not exist. Creating it.", _logGroupName); await this.CreateLogGroupAsync(); if (createStreamIfNotExists) { await this.CreateLogStreamAsync(logStreamName); } return; } } var logStream = describeLogsStreamsResponse.LogStreams .FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase)); if (logStream == null) { if (createStreamIfNotExists) { await this.CreateLogStreamAsync(logStreamName); } } else { _sequenceToken = logStream.UploadSequenceToken; } }
private async Task GetSequenceTokenAsync(string logGroup, string logStreamName, bool createStreamIfNotExists, CancellationToken stopToken) { var request = new DescribeLogStreamsRequest { LogGroupName = logGroup, LogStreamNamePrefix = logStreamName }; try { var describeLogsStreamsResponse = await _cloudWatchLogsClient.DescribeLogStreamsAsync(request, stopToken); var logStream = describeLogsStreamsResponse.LogStreams .FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase)); if (logStream == null) { if (createStreamIfNotExists) { await CreateLogStreamAsync(logGroup, logStreamName, stopToken); } } else { _sequenceToken = logStream.UploadSequenceToken; } _throttle.SetSuccess(); } catch (ResourceNotFoundException rex) { // Create the log group if it doesn't exist. if (rex.Message.Contains("log group does not exist", StringComparison.OrdinalIgnoreCase)) { _logger?.LogInformation("Log group {0} does not exist. Creating it.", logGroup); await CreateLogGroupAsync(logGroup, stopToken); if (createStreamIfNotExists) { await CreateLogStreamAsync(logGroup, logStreamName, stopToken); } return; } } }
/// <summary> /// Creates the log stream if needed. /// </summary> /// <exception cref="Serilog.Sinks.AwsCloudWatch.AwsCloudWatchSinkException"></exception> private async Task CreateLogStreamAsync() { // see if the log stream already exists DescribeLogStreamsRequest describeLogStreamsRequest = new DescribeLogStreamsRequest { LogGroupName = options.LogGroupName, LogStreamNamePrefix = logStreamName, Limit = 1 }; var describeLogStreamsResponse = await cloudWatchClient.DescribeLogStreamsAsync(describeLogStreamsRequest); var logStream = describeLogStreamsResponse.LogStreams.FirstOrDefault(ls => string.Equals(ls.LogStreamName, logStreamName, StringComparison.OrdinalIgnoreCase)); // create log stream if it doesn't exist if (logStream == null) { CreateLogStreamRequest createLogStreamRequest = new CreateLogStreamRequest { LogGroupName = options.LogGroupName, LogStreamName = logStreamName }; var createLogStreamResponse = await cloudWatchClient.CreateLogStreamAsync(createLogStreamRequest); } }
private async Task GetSequenceTokenAsync(string logStreamName) { var request = new DescribeLogStreamsRequest { LogGroupName = _logGroupName, LogStreamNamePrefix = logStreamName }; var describeLogsStreamsResponse = await _client.DescribeLogStreamsAsync(request); LogStream logStream = describeLogsStreamsResponse.LogStreams .FirstOrDefault(s => s.LogStreamName.Equals(logStreamName, StringComparison.CurrentCultureIgnoreCase)); if (logStream == null) { await CreateLogStreamAsync(logStreamName); } else { _sequenceToken = logStream.UploadSequenceToken; } }
public async Task DescribeLogStreamsTest__CancellationToken() { var request = new DescribeLogStreamsRequest(); var firstResponse = new DescribeLogStreamsResponse() { NextToken = "foo" }; var secondResponse = new DescribeLogStreamsResponse() { NextToken = null }; var paginator = _mockClient.Object.Paginators.DescribeLogStreams(request); var tokenSource = new CancellationTokenSource(); var token = tokenSource.Token; tokenSource.Cancel(); _mockClient.SetupSequence(x => x.DescribeLogStreamsAsync(It.IsAny <DescribeLogStreamsRequest>(), It.IsAny <CancellationToken>())) .ReturnsAsync(firstResponse) .ReturnsAsync(secondResponse); await Assert.ThrowsAsync <OperationCanceledException>(async() => await LoopOverLogStreams(paginator, token)); }
static void Main(string[] args) { var logClient = new AmazonCloudWatchLogsClient(); // Add a new log group for testing const string newLogGroupName = "NewLogGroup"; DescribeLogGroupsResponse dlgr = logClient.DescribeLogGroups(); var groups = new List <LogGroup> { }; groups = dlgr.LogGroups; LogGroup lg = new LogGroup(); lg.LogGroupName = newLogGroupName; // Look for our new log group name to determine if we need to do setup LogGroup result = groups.Find( delegate(LogGroup bk) { return(bk.LogGroupName == newLogGroupName); } ); if (result != null) { Console.WriteLine(result.LogGroupName + " found"); } else { //Haven't seen this log group, set it up CreateLogGroupRequest clgr = new CreateLogGroupRequest(newLogGroupName); logClient.CreateLogGroup(clgr); // Create a file to sace next SequenceToken in File.CreateText("..\\..\\" + lg.LogGroupName + ".txt"); CreateLogStreamRequest csr = new CreateLogStreamRequest(lg.LogGroupName, newLogGroupName); logClient.CreateLogStream(csr); } string tokenFile = ""; try { Console.WriteLine(lg.LogGroupName); //Pick up the next sequence token from the last run tokenFile = lg.LogGroupName; StreamReader sr = File.OpenText("..\\..\\" + tokenFile + ".txt"); string sequenceToken = sr.ReadLine(); sr.Close(); lg.RetentionInDays = 30; string groupName = lg.LogGroupName;; TestMetricFilterRequest tmfr = new TestMetricFilterRequest(); List <InputLogEvent> logEvents = new List <InputLogEvent>(3); InputLogEvent ile = new InputLogEvent(); ile.Message = "Test Event 1"; //DateTime dt = new DateTime(1394793518000); DateTime dt = new DateTime(2017, 01, 11); ile.Timestamp = dt; logEvents.Add(ile); ile.Message = "Test Event 2"; logEvents.Add(ile); ile.Message = "This message also contains an Error"; logEvents.Add(ile); DescribeLogStreamsRequest dlsr = new DescribeLogStreamsRequest(groupName); PutLogEventsRequest pler = new PutLogEventsRequest(groupName, tokenFile, logEvents); pler.SequenceToken = sequenceToken; //use last sequence token PutLogEventsResponse plerp = new PutLogEventsResponse(); plerp = logClient.PutLogEvents(pler); Console.WriteLine("Next sequence token = " + plerp.NextSequenceToken); FileStream fs = File.OpenWrite("..\\..\\" + tokenFile + ".txt"); fs.Position = 0; UTF8Encoding utf8 = new UTF8Encoding(); Byte[] encodedBytes = utf8.GetBytes(plerp.NextSequenceToken); fs.Write(encodedBytes, 0, utf8.GetByteCount(plerp.NextSequenceToken)); fs.Close(); List <string> lem = new List <string>(1); lem.Add("Error"); tmfr.LogEventMessages = lem; tmfr.FilterPattern = "Error"; TestMetricFilterResponse tmfrp = new TestMetricFilterResponse(); tmfrp = logClient.TestMetricFilter(tmfr); var results = new List <MetricFilterMatchRecord> { }; results = tmfrp.Matches; Console.WriteLine("Found " + results.Count.ToString() + " match records"); IEnumerator ie = results.GetEnumerator(); while (ie.MoveNext()) { MetricFilterMatchRecord mfmr = (MetricFilterMatchRecord)ie.Current; Console.WriteLine("Event Message = " + mfmr.EventMessage); } Console.WriteLine("Metric filter test done"); } catch (Exception e) { Console.WriteLine(e.Message); } }
/// <summary> /// Get all the LogStream from the chosen LogGroup /// </summary> /// <param name="awsLogGroupName"></param> /// <returns>return all LogStreams from the chosen LogGroup</returns> public DescribeLogStreamsResponse GetLogStreams(string awsLogGroupName) { awsLogStream = new DescribeLogStreamsRequest(); awsLogStream.LogGroupName = awsLogGroupName; return(awsCloudwatchClient.DescribeLogStreams(awsLogStream)); }
internal void ForwardLogs() { do { Action pushLogsToCloudWatchAction = () => { LogMessageDTO logMessageObj; while (LogService.taskQueue.TryDequeue(out logMessageObj)) { try { using (IAmazonCloudWatchLogs logsclient = Amazon.AWSClientFactory.CreateAmazonCloudWatchLogsClient(this.cloudWatchAccessKey, this.cloudWatchSecretKey, this.cloudWatchRegion)) { string logStreamName = string.IsNullOrWhiteSpace(logMessageObj.ApplicationAlias) ? "Custom" : logMessageObj.ApplicationAlias; // put the object into JSON format and send it to CloudWatch List <InputLogEvent> logEvents = new List <InputLogEvent>(); InputLogEvent logEntry = new InputLogEvent(); logEntry.Message = JsonConvert.SerializeObject(logMessageObj); logEntry.Timestamp = logMessageObj.Timestamp; logEvents.Add(logEntry); PutLogEventsRequest request = new PutLogEventsRequest(this.logGroupName, logStreamName, logEvents); PutLogEventsResponse response = null; for (int i = 0; i < 5; ++i) { try { lock (this.criticalSection) { // if we have a token, set it if (LogStreamTokenMap.ContainsKey(logStreamName)) { request.SequenceToken = LogStreamTokenMap[logStreamName]; } // put the logs and get the token for the next submissions of logs response = logsclient.PutLogEvents(request); var newToken = response.NextSequenceToken; if (LogStreamTokenMap.ContainsKey(logStreamName)) { LogStreamTokenMap[logStreamName] = newToken; } else { LogStreamTokenMap.Add(logStreamName, newToken); } } // if we successfully pushed the logs, exit the loop, otherwise we will exit in 5 tries break; } catch (InvalidSequenceTokenException) { // we don't have the right token for the next sequence in the stream, so get it again // in fact we will refresh all tokens for all streams var logstreamsrequest = new DescribeLogStreamsRequest(this.logGroupName); var logStreamResponse = logsclient.DescribeLogStreams(logstreamsrequest); var logstreamsList = logStreamResponse.LogStreams; lock (this.criticalSection) { foreach (var logstream in logstreamsList) { var appname = logstream.LogStreamName; var token = logstream.UploadSequenceToken; if (LogStreamTokenMap.ContainsKey(appname)) { LogStreamTokenMap[appname] = token; } else { LogStreamTokenMap.Add(appname, token); } } } } catch (ResourceNotFoundException) { // we likely introduced a new log stream that needs to be provisioned in CloudWatch // ignore exceptions in creation try { CreateLogGroupRequest logGroup = new CreateLogGroupRequest(this.logGroupName); logsclient.CreateLogGroup(logGroup); } catch (Exception) { } try { CreateLogStreamRequest logStream = new CreateLogStreamRequest(this.logGroupName, logStreamName); logsclient.CreateLogStream(logStream); lock (this.criticalSection) { LogStreamTokenMap.Remove(logStreamName); } } catch (Exception) { } } } if (response.HttpStatusCode == HttpStatusCode.OK) { ++LogService.successfulForwards; } else { ++LogService.failedForwards; } } } catch (Exception) { // can't really log this exception to avoid cyclical logging and deadlocks ++LogService.numExceptions; } } }; // Start 5 parallel tasks to consume the logs from the queue // the problem here is that the logs might not be pushed in order to CloudWatch // However, that's ok since there might be multiple instances of this service and logs could be coming // in to all instances at the same time and we might push logs to CloudWatch out of order Parallel.Invoke(pushLogsToCloudWatchAction, pushLogsToCloudWatchAction, pushLogsToCloudWatchAction, pushLogsToCloudWatchAction, pushLogsToCloudWatchAction); // sleep before getting into another iteration of this loop to look for logs Thread.Sleep(1000); } while (true); }
void Writer(object sender, ElapsedEventArgs e) { var logEvents = new List <InputLogEvent>(); try { var more = true; while (more) { InputLogEvent item; more = items.TryTake(out item); if (more) { logEvents.Add(item); } } if (logEvents.Count == 0) { return; } if (!Settings.Default.SendUsageData) { return; } using (var logs = new AmazonCloudWatchLogsClient(AwsKeys.AccessKey, AwsKeys.SecretKey, RegionEndpoint.APSoutheast2)) { var request = new PutLogEventsRequest(AwsKeys.GroupName, LogStreamName, logEvents); var describeLogStreamsRequest = new DescribeLogStreamsRequest(AwsKeys.GroupName) { LogStreamNamePrefix = trackingId, Descending = true }; var describeLogStreamsResponse = logs.DescribeLogStreams(describeLogStreamsRequest); var logStreams = describeLogStreamsResponse.LogStreams; var logStream = logStreams.FirstOrDefault(ls => ls.LogStreamName == LogStreamName); if (logStream != null) { var token = logStream.UploadSequenceToken; request.SequenceToken = token; checkResponse(logs.PutLogEvents(request)); } else { var createRequest = new CreateLogStreamRequest(AwsKeys.GroupName, LogStreamName); checkResponse(logs.CreateLogStream(createRequest)); checkResponse(logs.PutLogEvents(request)); } } } catch (Exception ee) { AttempToRestoreErrors(logEvents, ee); } finally { if (timer != null) { timer.Start(); } } }
/// <summary> /// /// <para>WriteLogs:</para> /// /// <para>Writes logs to the logging service</para> /// /// <para>Check <seealso cref="IBLoggingServiceInterface.WriteLogs"/> for detailed documentation</para> /// /// </summary> public bool WriteLogs( List <BLoggingParametersStruct> _Messages, string _LogGroupName, string _LogStreamName, bool _bAsync = true, Action <string> _ErrorMessageAction = null) { if (_Messages == null || _Messages.Count == 0) { return(false); } if (_bAsync) { BTaskWrapper.Run(() => { WriteLogs(_Messages, _LogGroupName, _LogStreamName, false, _ErrorMessageAction); }); return(true); } else { _LogGroupName = BUtility.EncodeStringForTagging(_LogGroupName); _LogStreamName = BUtility.EncodeStringForTagging(_LogStreamName); string SequenceToken = null; bool bLogStreamAndGroupExists = false; try { var DescribeStreamRequest = new DescribeLogStreamsRequest(_LogGroupName); using (var CreatedDescribeTask = CloudWatchLogsClient.DescribeLogStreamsAsync(DescribeStreamRequest)) { CreatedDescribeTask.Wait(); if (CreatedDescribeTask.Result != null && CreatedDescribeTask.Result.LogStreams != null && CreatedDescribeTask.Result.LogStreams.Count > 0) { foreach (var Current in CreatedDescribeTask.Result.LogStreams) { if (Current != null && Current.LogStreamName == _LogStreamName) { SequenceToken = Current.UploadSequenceToken; bLogStreamAndGroupExists = true; break; } } } } } catch (Exception) { bLogStreamAndGroupExists = false; } if (!bLogStreamAndGroupExists) { try { var CreateGroupRequest = new CreateLogGroupRequest(_LogGroupName); using (var CreatedGroupTask = CloudWatchLogsClient.CreateLogGroupAsync(CreateGroupRequest)) { CreatedGroupTask.Wait(); } } catch (Exception e) { if (!(e is ResourceAlreadyExistsException)) { _ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace); return(false); } } try { var CreateStreamRequest = new CreateLogStreamRequest(_LogGroupName, _LogStreamName); using (var CreatedStreamTask = CloudWatchLogsClient.CreateLogStreamAsync(CreateStreamRequest)) { CreatedStreamTask.Wait(); } } catch (Exception e) { if (!(e is ResourceAlreadyExistsException)) { _ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace); return(false); } } } var LogEvents = new List <InputLogEvent>(); foreach (var Message in _Messages) { var LogEvent = new InputLogEvent() { Message = Message.Message, Timestamp = DateTime.UtcNow }; switch (Message.LogType) { case EBLoggingServiceLogType.Debug: LogEvent.Message = "Debug-> " + LogEvent.Message; break; case EBLoggingServiceLogType.Info: LogEvent.Message = "Info-> " + LogEvent.Message; break; case EBLoggingServiceLogType.Warning: LogEvent.Message = "Warning-> " + LogEvent.Message; break; case EBLoggingServiceLogType.Error: LogEvent.Message = "Error-> " + LogEvent.Message; break; case EBLoggingServiceLogType.Critical: LogEvent.Message = "Critical-> " + LogEvent.Message; break; } LogEvents.Add(LogEvent); } try { var PutRequest = new PutLogEventsRequest(_LogGroupName, _LogStreamName, LogEvents) { SequenceToken = SequenceToken }; using (var CreatedPutTask = CloudWatchLogsClient.PutLogEventsAsync(PutRequest)) { CreatedPutTask.Wait(); } } catch (Exception e) { _ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace); return(false); } return(true); } }