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();
}
}
