public void ILogger() { LoggerConfigSectionSetup("appsettings.json", null); var logger = LoggerSetup(); for (int i = 0; i < 10; i++) { logger.LogDebug(string.Format("Test logging message {0} Ilogger", i)); } //Sleep is introduced to give suffiecient time for the logstream to get posted on CloudWatchLogs Thread.Sleep(5000); string region = _configSection.Config.Region; string logGroupName = _configSection.Config.LogGroup; AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest { LogGroupName = logGroupName, LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName }).Result; Assert.Equal(10, getLogEventsResponse.Events.Count()); }
public void Log4Net() { XmlConfigurator.Configure(new System.IO.FileInfo("log4net.config")); logger = LogManager.GetLogger("Log4Net"); for (int i = 0; i < 10; i++) { logger.Debug(string.Format("Test logging message {0} Log4Net", i)); } //Added Sleep to give sufficient time for the log stream to get posted on CloudWatch Thread.Sleep(10000); string region = "us-west-2"; string logGroupName = "AWSLog4NetGroupLog4Net"; AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest { LogGroupName = logGroupName, LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName }).Result; Assert.Equal(10, getLogEventsResponse.Events.Count()); }
private List <string> GetLogMessages(string lambdaName) { var logGroup = GetLogGroup(lambdaName); _logsClient = new AmazonCloudWatchLogsClient(); var logStreams = _logsClient .DescribeLogStreamsAsync(new DescribeLogStreamsRequest(logGroup)).Result .LogStreams; var responses = new List <GetLogEventsResponse>(); foreach (var logStream in logStreams) { responses.Add(_logsClient.GetLogEventsAsync(new GetLogEventsRequest(logGroup, logStream.LogStreamName)).Result); } // Each response has many events so // simple Select would yield a nested array [[event1, event2,...event99] , [event101, event102,...event199] , [event200, event201,...event299]] // SelectMany flattens the array [event1, event2,...event299]] var messages = responses.SelectMany(x => x.Events) .Where(x => x.Message.StartsWith("Location:")) .Select(x => x.Message) .ToList(); return(messages); }
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 <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); }
private async Task <string> GetSequenceToken(string logGroupName, string logStreamName) { await CreateLogStreamAsync(logGroupName, logStreamName); var logStreamsResponse = await _client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest(logGroupName) { LogStreamNamePrefix = logStreamName, }); var stream = logStreamsResponse.LogStreams.First(s => s.LogStreamName == logStreamName); return(stream.UploadSequenceToken); }
public List <FilteredLogEvent> FilterLogStream(string logGroupName, string message) { var result = Client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; var streamName = result.LogStreams[0].LogStreamName; var logFilterResponse = Client.FilterLogEventsAsync(new FilterLogEventsRequest { LogGroupName = logGroupName, LogStreamNames = new List <string> { streamName }, FilterPattern = message }).Result; return(logFilterResponse.Events); }
public void MultiThreadBufferFullTest() { global::NLog.Logger logger; try { LogManager.Configuration = new XmlLoggingConfiguration("Regular.config"); } catch (FileNotFoundException) { LogManager.Configuration = new XmlLoggingConfiguration("./test/AWS.Logger.NLog.Tests/Regular.config"); } logger = LogManager.GetLogger("loggerMultiThreadBufferFull"); var tasks = new List <Task>(); var streamNames = new List <string>(); var count = 200; var totcount = 0; for (int i = 0; i < 2; i++) { tasks.Add(Task.Factory.StartNew(() => NLogThread(count, logger))); totcount = totcount + count; } Task.WaitAll(tasks.ToArray()); string region = "us-west-2"; string logGroupName = "AWSNLogGroupMultiThreadBufferFullTest"; Thread.Sleep(10000); AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; List <string> logStreamNames = new List <string>(); logStreamNames.Add(describeLogstreamsResponse.LogStreams[0].LogStreamName); FilterLogEventsResponse filterLogEventsResponse = client.FilterLogEventsAsync(new FilterLogEventsRequest { FilterPattern = "maximum", LogGroupName = logGroupName, LogStreamNames = logStreamNames }).Result; Assert.NotEmpty(filterLogEventsResponse.Events); }
public bool FilterPatternExists(string logGroupName, string filterPattern) { DescribeLogStreamsResponse describeLogstreamsResponse; try { describeLogstreamsResponse = Client. DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; } catch (Exception) { return(false); } if (describeLogstreamsResponse.LogStreams.Count > 0) { List <string> logStreamNames = new List <string>(); logStreamNames.Add(describeLogstreamsResponse.LogStreams[0].LogStreamName); FilterLogEventsResponse filterLogEventsResponse = Client. FilterLogEventsAsync(new FilterLogEventsRequest { FilterPattern = filterPattern, LogGroupName = logGroupName, LogStreamNames = logStreamNames }).Result; return(filterLogEventsResponse.Events.Count > 0); } else { return(false); } }
static async Task Main(string[] args) { var accessKey = ConfigurationManager.AppSettings["accessKey"]; var secretAccessKey = ConfigurationManager.AppSettings["secretAccessKey"]; var region = Amazon.RegionEndpoint.GetBySystemName(ConfigurationManager.AppSettings["region"]); var groupName = ConfigurationManager.AppSettings["groupName"]; var cloudWatchLogClient = new AmazonCloudWatchLogsClient(accessKey, secretAccessKey, region); var reqestCounter = 0; BigInteger firstLogStreamName = 0; DescribeLogStreamsResponse lastResponse = new DescribeLogStreamsResponse(); var isEndOfStream = false; while (isEndOfStream == false) { var describeLogStreamsRequest = (reqestCounter == 0) ? new DescribeLogStreamsRequest(groupName) { Limit = 50 } : new DescribeLogStreamsRequest(groupName) { Limit = 50, NextToken = lastResponse.NextToken }; var describeLogStreamsResponse = await cloudWatchLogClient.DescribeLogStreamsAsync(describeLogStreamsRequest); var logStreams = describeLogStreamsResponse.LogStreams; for (int j = 0; j < logStreams.Count; j++) { //0は正の符号 var i = BigInteger.Parse("0" + logStreams[j].LogStreamName, NumberStyles.HexNumber); if (firstLogStreamName < i) { Console.WriteLine(logStreams[j].LogStreamName); } else { isEndOfStream = true; break; } } firstLogStreamName = (reqestCounter == 0) ? BigInteger.Parse("0" + describeLogStreamsResponse.LogStreams[0].LogStreamName, NumberStyles.HexNumber) : firstLogStreamName; lastResponse = describeLogStreamsResponse; reqestCounter++; } Console.ReadKey(); }
public void MultiThreadBufferFullTest() { ILog logger; XmlConfigurator.Configure(new System.IO.FileInfo("log4net.config")); logger = LogManager.GetLogger("MultiThreadBufferFullTest"); var tasks = new List <Task>(); var count = 200; var totcount = 0; for (int i = 0; i < 2; i++) { tasks.Add(Task.Factory.StartNew(() => Log4NetThread(count, logger))); totcount = totcount + count; } Task.WaitAll(tasks.ToArray(), 10000); Thread.Sleep(10000); string region = "us-west-2"; string logGroupName = "AWSLog4NetGroupMultiThreadBufferFullTest"; AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; List <string> logStreamNames = new List <string>(); logStreamNames.Add(describeLogstreamsResponse.LogStreams[0].LogStreamName); FilterLogEventsResponse filterLogEventsResponse = client.FilterLogEventsAsync(new FilterLogEventsRequest { FilterPattern = "maximum", LogGroupName = logGroupName, LogStreamNames = logStreamNames }).Result; Assert.NotEmpty(filterLogEventsResponse.Events); }
public void MultiThreadBufferFullTest() { var tasks = new List <Task>(); var streamNames = new List <string>(); ILoggerMultiThreadTestSetup("multiThreadBufferFullTest.json"); logger = ILoggerTest.LoggerSetup(); var count = 200; var totcount = 0; for (int i = 0; i < 2; i++) { tasks.Add(Task.Factory.StartNew(() => ILoggerThread(count))); totcount = totcount + count; } Task.WaitAll(tasks.ToArray(), 10000); //Sleep is introduced to give suffiecient time for the logstream to get posted on CloudWatchLogs Thread.Sleep(5000); string region = ILoggerTest._configSection.Config.Region; string logGroupName = ILoggerTest._configSection.Config.LogGroup; AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; List <string> logStreamNames = new List <string>(); logStreamNames.Add(describeLogstreamsResponse.LogStreams[0].LogStreamName); FilterLogEventsResponse filterLogEventsResponse = client.FilterLogEventsAsync(new FilterLogEventsRequest { FilterPattern = "maximum", LogGroupName = logGroupName, LogStreamNames = logStreamNames }).Result; Assert.NotEmpty(filterLogEventsResponse.Events); }
public void MultiThreadTest() { ILog logger; XmlConfigurator.Configure(new System.IO.FileInfo("log4net.config")); logger = LogManager.GetLogger("MultiThreadTest"); var log = LogManager.GetCurrentLoggers(); var tasks = new List <Task>(); var count = 200; var totcount = 0; for (int i = 0; i < 2; i++) { tasks.Add(Task.Factory.StartNew(() => Log4NetThread(count, logger))); totcount = totcount + count; } Task.WaitAll(tasks.ToArray(), 10000); //Added Sleep to give sufficient time for the log stream to get posted on CloudWatch Thread.Sleep(5000); string region = "us-west-2"; string logGroupName = "AWSLog4NetGroupLog4NetMultiThreadTest"; AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest { LogGroupName = logGroupName, LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName }).Result; Assert.Equal(totcount, getLogEventsResponse.Events.Count()); }
public void Nlog() { try { LogManager.Configuration = new XmlLoggingConfiguration("Regular.config"); } catch (FileNotFoundException) { LogManager.Configuration = new XmlLoggingConfiguration("./test/AWS.Logger.NLog.Tests/Regular.config"); } global::NLog.Logger logger = LogManager.GetLogger("loggerRegular"); for (int i = 0; i < 10; i++) { logger.Debug(string.Format("Test logging message {0} NLog, Thread Id:{1}", i, Thread.CurrentThread.ManagedThreadId)); } string region = "us-west-2"; string logGroupName = "AWSNLogGroup"; Thread.Sleep(10000); AmazonCloudWatchLogsClient client = new AmazonCloudWatchLogsClient( Amazon.RegionEndpoint.GetBySystemName(region)); DescribeLogStreamsResponse describeLogstreamsResponse = client.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = logGroupName, OrderBy = "LastEventTime" }).Result; GetLogEventsResponse getLogEventsResponse = client.GetLogEventsAsync(new GetLogEventsRequest { LogGroupName = logGroupName, LogStreamName = describeLogstreamsResponse.LogStreams[0].LogStreamName }).Result; Assert.Equal(10, getLogEventsResponse.Events.Count()); }
public async Task ListLambdasAsync(string awsProfile, string awsRegion) { Console.WriteLine(); // initialize AWS profile await InitializeAwsProfile(awsProfile, awsRegion : awsRegion); var cfnClient = new AmazonCloudFormationClient(AWSConfigs.RegionEndpoint); var lambdaClient = new AmazonLambdaClient(AWSConfigs.RegionEndpoint); var logsClient = new AmazonCloudWatchLogsClient(AWSConfigs.RegionEndpoint); // fetch all Lambda functions on account var globalFunctions = (await ListLambdasAsync()) .ToDictionary(function => function.FunctionName, function => function); // fetch all stacks on account var stacks = await ListStacksAsync(); Console.WriteLine($"Analyzing {stacks.Count():N0} CloudFormation stacks and {globalFunctions.Count():N0} Lambda functions"); // fetch most recent CloudWatch log stream for each Lambda function var logStreamsTask = Task.Run(async() => (await Task.WhenAll(globalFunctions.Select(async kv => { try { var response = await logsClient.DescribeLogStreamsAsync(new DescribeLogStreamsRequest { Descending = true, LogGroupName = $"/aws/lambda/{kv.Value.FunctionName}", OrderBy = OrderBy.LastEventTime, Limit = 1 }); return(Name: kv.Value.FunctionName, Streams: response.LogStreams.FirstOrDefault()); } catch { // log group doesn't exist return(Name: kv.Value.FunctionName, Streams: null); } }))).ToDictionary(tuple => tuple.Name, tuple => tuple.Streams)); // fetch all functions belonging to a CloudFormation stack var stacksWithFunctionsTask = Task.Run(async() => stacks.Zip( await Task.WhenAll(stacks.Select(stack => ListStackFunctionsAsync(stack.StackId))), (stack, stackFunctions) => (Stack: stack, Functions: stackFunctions) ).ToList() ); // wait for both fetch operations to finish await Task.WhenAll(logStreamsTask, stacksWithFunctionsTask); var logStreams = logStreamsTask.GetAwaiter().GetResult(); var stacksWithFunctions = stacksWithFunctionsTask.GetAwaiter().GetResult(); // remove all the functions that were discovered inside a stack from the orphaned list of functions foreach (var function in stacksWithFunctions.SelectMany(stackWithFunctions => stackWithFunctions.Functions)) { globalFunctions.Remove(function.Configuration.FunctionName); } // compute the max width for the function name (use logical ID if it belongs to the stack) var maxFunctionNameWidth = stacksWithFunctions .SelectMany(stackWithFunctions => stackWithFunctions.Functions) .Select(function => function.Name.Length) .Union(globalFunctions.Values.Select(function => function.FunctionName.Length)) .Append(0) .Max(); // compute max width for the function runtime name var maxRuntimeWidth = stacksWithFunctions .SelectMany(stackWithFunctions => stackWithFunctions.Functions) .Select(stackFunction => stackFunction.Configuration.Runtime.ToString().Length) .Union(globalFunctions.Values.Select(function => function.Runtime.ToString().Length)) .Append(0) .Max(); // print Lambda functions belonging to stacks var showAsteriskExplanation = false; foreach (var stackWithFunctions in stacksWithFunctions .Where(stackWithFunction => stackWithFunction.Functions.Any()) .OrderBy(stackWithFunction => stackWithFunction.Stack.StackName) ) { Console.WriteLine(); // check if CloudFormation stack was deployed by LambdaSharp var moduleInfoOutput = stackWithFunctions.Stack.Outputs .FirstOrDefault(output => (output.OutputKey == "ModuleInfo") || (output.OutputKey == "Module")) ?.OutputValue; var lambdaSharpToolOutput = stackWithFunctions.Stack.Outputs .FirstOrDefault(output => output.OutputKey == "LambdaSharpTool") ?.OutputValue; // NOTE (2020-05-06, bjorg): pre-0.6, the module information was emitted as two output values var moduleNameOutput = stackWithFunctions.Stack.Outputs .FirstOrDefault(output => output.OutputKey == "ModuleName") ?.OutputValue; var moduleVersionOutput = stackWithFunctions.Stack.Outputs .FirstOrDefault(output => output.OutputKey == "ModuleVersion") ?.OutputValue; // show CloudFormation stack name and optionally LambdaSharp module information Console.Write($"{Settings.OutputColor}{stackWithFunctions.Stack.StackName}{Settings.ResetColor}"); if (ModuleInfo.TryParse(moduleInfoOutput, out var moduleInfo)) { Console.Write($" ({Settings.InfoColor}{moduleInfo.FullName}:{moduleInfo.Version}{Settings.ResetColor}) [lash {lambdaSharpToolOutput ?? "pre-0.6.1"}]"); } else if ((moduleNameOutput != null) && (moduleVersionOutput != null)) { Console.Write($" ({Settings.InfoColor}{moduleNameOutput}:{moduleVersionOutput}{Settings.ResetColor}) [lash pre-0.6]"); } Console.WriteLine(":"); foreach (var function in stackWithFunctions.Functions.OrderBy(function => function.Name)) { PrintFunction(function.Name, function.Configuration); } } // print orphan Lambda functions if (globalFunctions.Any()) { Console.WriteLine(); Console.WriteLine("ORPHANS:"); foreach (var function in globalFunctions.Values.OrderBy(function => function.FunctionName)) { PrintFunction(function.FunctionName, function); } } // show optional (*) explanation if it was printed if (showAsteriskExplanation) { Console.WriteLine(); Console.WriteLine("(*) Showing Lambda last-modified date, because last event timestamp in CloudWatch log stream is not available"); } // local functions async Task <IEnumerable <FunctionConfiguration> > ListLambdasAsync() { var result = new List <FunctionConfiguration>(); var request = new ListFunctionsRequest(); do { var response = await lambdaClient.ListFunctionsAsync(request); result.AddRange(response.Functions); request.Marker = response.NextMarker; } while(request.Marker != null); return(result); } async Task <IEnumerable <Stack> > ListStacksAsync() { var result = new List <Stack>(); var request = new DescribeStacksRequest(); do { var response = await cfnClient.DescribeStacksAsync(request); result.AddRange(response.Stacks); request.NextToken = response.NextToken; } while(request.NextToken != null); return(result); } async Task <IEnumerable <(string Name, FunctionConfiguration Configuration)> > ListStackFunctionsAsync(string stackName) { var result = new List <(string, FunctionConfiguration)>(); var request = new ListStackResourcesRequest { StackName = stackName }; do { var attempts = 0; again: try { var response = await cfnClient.ListStackResourcesAsync(request); result.AddRange( response.StackResourceSummaries .Where(resourceSummary => resourceSummary.ResourceType == "AWS::Lambda::Function") .Select(summary => { globalFunctions.TryGetValue(summary.PhysicalResourceId, out var configuration); return(Name: summary.LogicalResourceId, Configuration: configuration); }) .Where(tuple => tuple.Configuration != null) ); request.NextToken = response.NextToken; } catch (AmazonCloudFormationException e) when( (e.Message == "Rate exceeded") && (++attempts < 30) ) { await Task.Delay(TimeSpan.FromSeconds(attempts)); goto again; } } while(request.NextToken != null); return(result); } void PrintFunction(string name, FunctionConfiguration function) { Console.Write(" "); Console.Write(name); Console.Write("".PadRight(maxFunctionNameWidth - name.Length + 4)); Console.Write(function.Runtime); Console.Write("".PadRight(maxRuntimeWidth - function.Runtime.ToString().Length + 4)); if ( !logStreams.TryGetValue(function.FunctionName, out var logStream) || (logStream?.LastEventTimestamp == null) ) { Console.Write(DateTimeOffset.Parse(function.LastModified).ToString("yyyy-MM-dd")); Console.Write("(*)"); showAsteriskExplanation = true; } else { Console.Write(logStream.LastEventTimestamp.ToString("yyyy-MM-dd")); } Console.WriteLine(); } }
/// <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); } }
/// <summary> /// Opens the component. /// </summary> /// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param> public async Task OpenAsync(string correlationId) { if (IsOpen()) { return; } var awsConnection = await _connectionResolver.ResolveAsync(correlationId); // Assign service name awsConnection.Service = "logs"; awsConnection.ResourceType = "log-group"; if (!string.IsNullOrEmpty(awsConnection.Resource)) { _group = awsConnection.Resource; } // Undefined stream creates a random stream on every connect if (string.IsNullOrEmpty(_stream)) { _stream = IdGenerator.NextLong(); } // Validate connection params var err = awsConnection.Validate(correlationId); if (err != null) { throw err; } // Create client var region = RegionEndpoint.GetBySystemName(awsConnection.Region); var config = new AmazonCloudWatchLogsConfig() { RegionEndpoint = region }; _client = new AmazonCloudWatchLogsClient(awsConnection.AccessId, awsConnection.AccessKey, config); // Create a log group if needed try { await _client.CreateLogGroupAsync( new CreateLogGroupRequest { LogGroupName = _group } ); } catch (ResourceAlreadyExistsException) { // Ignore. Everything is ok } // Create or read log stream try { await _client.CreateLogStreamAsync( new CreateLogStreamRequest { LogGroupName = _group, LogStreamName = _stream } ); _lastToken = null; } catch (ResourceAlreadyExistsException) { var response = await _client.DescribeLogStreamsAsync( new DescribeLogStreamsRequest { LogGroupName = _group, LogStreamNamePrefix = _stream } ); if (response.LogStreams.Count > 0) { _lastToken = response.LogStreams[0].UploadSequenceToken; } } if (_timer == null) { _timer = new FixedRateTimer(OnTimer, _interval, _interval); _timer.Start(); } }