private void Build(EventSourceModel eventSourceModel, EventModel model)
{
if (model == null)
{
return;
}
if (model.MessageFormatter != null)
{
return;
}
var messageFormatBuilder = new ListBuilder($"{model.Name.GetHumanReadable()}", " ", " ");
var nextArgumentIndex = 1;
var messageArgumentIndex = -1;
foreach (var argument in model.GetAllArgumentsExpanded())
{
if (!argument.IsImplicit)
{
messageFormatBuilder.Append($"{{{nextArgumentIndex - 1}}}");
}
if (argument.Name.Equals("message", StringComparison.InvariantCultureIgnoreCase))
{
messageArgumentIndex = nextArgumentIndex;
}
nextArgumentIndex++;
}
model.MessageFormatter = messageArgumentIndex >= 0 ? $"{{{messageArgumentIndex - 1}}}" : messageFormatBuilder.ToString();
}
private void Build(Project project, EventSourceModel eventSource, EventModel model)
{
if (eventSource == null)
{
LogError($"{nameof(eventSource)} should not be null");
return;
}
foreach (var argument in model.GetAllArguments())
{
if (TypeExtensions.IsComplexType(argument.Type) && (argument.TypeTemplate == null))
{
var template = this.GetTypeTemplate(project, eventSource.TypeTemplates, argument);
if (template == null && eventSource.Settings.ImplicitTypeTemplates)
{
foreach (var implicitTypeTemplateNamespace in eventSource.Settings.ImplicitTypeTemplateNamespaces ?? new string[0])
{
if (argument.Type.StartsWith(implicitTypeTemplateNamespace))
{
var typeTemplate = new TypeTemplateModel()
{
Arguments = GetTypeArguments(project, argument.Type).ToArray(),
CLRType = argument.Type,
Name = argument.Type
};
argument.TypeTemplate = typeTemplate;
}
}
}
}
}
}
public string Render(Project project, EventSourceModel eventSource, ExtensionsMethodModel model)
{
if (!eventSource.Settings.UseReferencedHelpers)
{
if (model.Type == "AsJson")
{
var output = EventSourceExtensionMethodTemplate.Template_EXTENSION_ASJSON_DECLARATION;
output = output.Replace(EventSourceExtensionMethodTemplate.Template_EXTENSION_CLRTYPE,
model.CLRType);
return(output.ToString());
}
else if (model.Type == "GetReplicaOrInstanceId")
{
var output = EventSourceExtensionMethodTemplate
.Template_EXTENSION_GETREPLICAORINSTANCEID_DECLARATION;
return(output.ToString());
}
else if (model.Type == "GetContentDigest")
{
var output = EventSourceExtensionMethodTemplate.Template_EXTENSION_GETCONTENTDIGEST_DECLARATION;
return(output.ToString());
}
else if (model.Type == "GetMD5Hash")
{
var output = EventSourceExtensionMethodTemplate.Template_EXTENSION_GETMD5HASH_DECLARATION;
return(output.ToString());
}
}
return(null);
}
public void should_serialize_keywords_as_string_array()
{
var eventSourceModel = new EventSourceModel();
eventSourceModel.Keywords = new KeywordModel[]
{
new KeywordModel()
{
Name = "Keyword1", Value = 1
},
new KeywordModel()
{
Name = "Keyword2", Value = 2
},
new KeywordModel()
{
Name = "Keyword3", Value = 3
},
};
var converters = new List <JsonConverter> {
new KeywordModelJsonConverter()
};
var jsonFile = Newtonsoft.Json.JsonConvert.SerializeObject(eventSourceModel, Newtonsoft.Json.Formatting.None, new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
Converters = converters
});
Console.WriteLine(jsonFile);
jsonFile.Should().Be(@"{""Keywords"":[""Keyword1"",""Keyword2"",""Keyword3""]}");
}
public string Render(Project project, EventSourceModel eventSource, KeywordModel model)
{
var output = EventSourceKeywordTemplate.Template_KEYWORD;
output = output.Replace(EventSourceKeywordTemplate.Template_KEYWORD_NAME, model.Name);
output = output.Replace(EventSourceKeywordTemplate.Template_KEYWORD_INDEX, model.Value.ToString());
return(output);
}
public string Render(Project project, EventSourceModel eventSource, EventTaskModel model)
{
var output = EventSourceEventTaskTemplate.Template_EVENTTASK;
output = output.Replace(EventSourceEventTaskTemplate.Template_EVENTTASK_NAME, model.Name);
output = output.Replace(EventSourceEventTaskTemplate.Template_EVENTTASK_INDEX, model.Value.ToString());
return(output);
}
public void ExpandScopedEvents(EventSourceModel eventSource, LoggerModel model)
{
var scopeEvents = model.Events.Where(e => e.ReturnType == "System.IDisposable");
var events = new List <EventModel>(model.Events);
foreach (var eventModel in scopeEvents)
{
var eventBaseName = eventModel.Name;
eventModel.Name = $"Start{eventBaseName}";
eventModel.OpCode = EventOpcode.Start;
var eventTask = eventSource.GetEventTask(eventBaseName);
if (eventTask == null)
{
eventTask = eventSource.AddEventTask(eventBaseName);
}
eventModel.Task = eventTask;
if (eventModel.ReturnType == "System.IDisposable")
{
eventModel.IsScopedOperation = true;
eventModel.OperationName = GetEventOperationName(eventModel);
}
var stopEvent = new EventModel()
{
Arguments = eventModel.Arguments.Select(a => (EventArgumentModel)a.Clone()).ToArray(),
Name = $"Stop{eventBaseName}",
OpCode = EventOpcode.Stop,
Task = eventTask,
IsScopedOperation = eventModel.IsScopedOperation,
OperationName = eventModel.OperationName,
Keywords = eventModel.Keywords,
HasComplexArguments = eventModel.HasComplexArguments,
CorrelatesTo = eventModel,
ImplicitArguments = eventModel.ImplicitArguments,
Level = eventModel.Level,
MessageFormatter = eventModel.MessageFormatter,
};
eventModel.CorrelatesTo = stopEvent;
var index = events.IndexOf(eventModel);
if (index == events.Count - 1)
{
events.Add(stopEvent);
}
else
{
events.Insert(events.IndexOf(eventModel) + 1, stopEvent);
}
}
model.Events = events.ToArray();
}
private static void AddKnownExtension(EventSourceModel eventSource, string extensionName, string clrType)
{
if (!eventSource.Extensions.Any(ext => ext.CLRType == clrType && ext.Type == extensionName))
{
eventSource.Extensions.Add(new ExtensionsMethodModel()
{
CLRType = clrType, Type = extensionName
});
}
}
async Task IEventSourceRepository.AddEventStoreAsync(EventSourceModel eventSourceModel)
{
try
{
await
mongoDatabase
?.GetCollection <EventSourceModel>("EventSource")
?.InsertOneAsync(eventSourceModel);
}
catch
{
throw;
}
}
public IEnumerable <ProjectItem> Build(Project project, EventSourceModel model)
{
var outputs = new List <ProjectItem>();
// TODO: Get all builders from project and allow all to build
var eventSourceBuilders = new IEventSourceBuilder[]
{
new EventSourceKeywordBuilder(),
new EventSourceLoggersBuilder(),
new EventSourceEventsBuilder(),
new EventSourceExtensionsMethodsBuilder(),
};
foreach (var builder in eventSourceBuilders)
{
builder.Build(project, model);
}
return(outputs);
}
private void Build(Project project, EventSourceModel eventSource, EventModel model)
{
if (eventSource == null)
{
LogError($"{nameof(eventSource)} should not be null");
return;
}
foreach (var argument in model.GetAllArguments())
{
if (TypeExtensions.IsComplexType(argument.Type) && (argument.TypeTemplate == null))
{
var template = this.GetTypeTemplate(project, eventSource.TypeTemplates, argument);
if (template != null)
{
argument.TypeTemplate = template;
}
}
}
}
private static void AddKnownExtensions(EventSourceModel eventSource, EventArgumentModel argument)
{
if (argument.TypeTemplate != null)
{
foreach (var templateArgument in argument.GetTypeTemplateArguments())
{
AddKnownExtensions(eventSource, templateArgument);
}
}
if (argument.Assignment == null)
{
return;
}
var templateCLRType = argument.AssignedCLRType ?? argument.TemplatedParentArgument?.CLRType ?? argument?.TemplatedParentArgument?.Type ?? argument.Type;
if (argument.Assignment.Contains("$this.AsJson()"))
{
AddKnownExtension(eventSource, "AsJson", templateCLRType);
return;
}
if (argument.Assignment.Contains("$this.GetReplicaOrInstanceId()"))
{
AddKnownExtension(eventSource, "GetReplicaOrInstanceId", templateCLRType);
return;
}
if (argument.Assignment.Contains("$this.GetContentDigest("))
{
AddKnownExtension(eventSource, "GetContentDigest", templateCLRType);
AddKnownExtension(eventSource, "GetMD5Hash", templateCLRType);
return;
}
if (argument.Assignment.Contains("$this.GetMD5Hash("))
{
AddKnownExtension(eventSource, "GetMD5Hash", templateCLRType);
return;
}
}
private void AddDefaultEventSource(Project project)
{
var defaultEventSourceProjectItem = project.ProjectItems.GetDefaultEventSourceProjectItem();
if (defaultEventSourceProjectItem != null)
{
var defaultEventSource = new EventSourceModel()
{
Namespace = defaultEventSourceProjectItem.RootNamespace,
Name = "DefaultEventSource",
ProviderName = $"{defaultEventSourceProjectItem.RootNamespace.Replace('.', '-')}-Default",
ClassName = "DefaultEventSource",
TypeTemplates = new TypeTemplateModel[]
{
new TypeTemplateModel()
{
Name = "Exception",
CLRType = "System.Exception",
Arguments = new EventArgumentModel[]
{
new EventArgumentModel("message", "string", "$this.Message"),
new EventArgumentModel("source", "string", "$this.Source"),
new EventArgumentModel("exceptionTypeName", "string", "$this.GetType().FullName"),
new EventArgumentModel("exception", "string", "$this.AsJson()"),
}
}
}
};
var eventSourceLoggers = new List <LoggerModel>();
var startId = 1000;
foreach (var logger in project.Loggers)
{
eventSourceLoggers.Add(new LoggerModel()
{
Name = logger.Name,
StartId = startId,
ImplicitArguments = new EventArgumentModel[]
{
new EventArgumentModel()
{
Name = "autogenerated", Type = "bool"
},
new EventArgumentModel()
{
Name = "machineName", Type = "string", Assignment = "Environment.MachineName"
},
}
});
startId += 1000;
}
defaultEventSource.Loggers = eventSourceLoggers.ToArray();
// TODO: Move this to a renderer
var sourceFileName = System.IO.Path.GetFileName(defaultEventSourceProjectItem.Name);
var implementationFileName = $"{System.IO.Path.GetFileNameWithoutExtension(defaultEventSourceProjectItem.Name)}.cs";
var fileRelativePath = defaultEventSourceProjectItem.Name.RemoveFromStart(project.ProjectBasePath + System.IO.Path.DirectorySeparatorChar).Replace(sourceFileName, implementationFileName);
defaultEventSource.Include = fileRelativePath;
defaultEventSource.SourceFilePath = defaultEventSourceProjectItem.Include;
defaultEventSourceProjectItem.Content = defaultEventSource;
//var newProjectItem = new ProjectItem(
// type: ProjectItemType.DefaultGeneratedEventSourceDefinition,
// name: defaultEventSourceProjectItem.Name,
// content: jsonFile,
// include: defaultEventSourceProjectItem.Include)
//{
// RootNamespace = defaultEventSourceProjectItem.RootNamespace
//};
//project.AddProjectItem(newProjectItem);
}
}
private string RenderMethod(Project project, ProjectItem <LoggerModel> loggerProjectItem, EventSourceModel eventSourceModel, EventModel model)
{
var eventName = model.Name;
var output = LoggerImplementationEventMethodTemplate.Template_LOGGER_METHOD;
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_NAME, eventName);
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_EVENTSOURCE_CLASS_NAME, eventSourceModel.ClassName);
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_RETURNTYPE, model.ReturnType ?? "void");
var methodArguments = new EventArgumentsListBuilder(
RenderMethodArgument, LoggerImplementationEventMethodTemplate.Template_LOGGER_IMPLICIT_ARGUMENTS_METHOD_DECLARATION_DELIMITER);
foreach (var argument in model.GetAllNonImplicitArguments())
{
methodArguments.Append(argument);
}
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_ARGUMENTS, methodArguments.ToString());
var methodImplementation = new StringBuilder();
var renderers = new ILoggerImplementationMethodRenderer[]
{
new LoggerImplementationMethodCallEventSourceEventRenderer(),
}.Union(project.GetExtensions <ILoggerImplementationMethodRenderer>(eventSourceModel.Settings?.Modules ?? new string[0])).ToArray();
foreach (var renderer in renderers)
{
PassAlongLoggers(renderer as IWithLogging);
methodImplementation.Append(renderer.Render(project, loggerProjectItem, model));
}
output = output.Replace(LoggerImplementationEventMethodTemplate.Variable_LOGGER_METHOD_IMPLEMENTATION, methodImplementation.ToString());
return(output);
}
public async Task AddAsync(EventModel eventModel)
{
var eventSourceModel = new EventSourceModel(eventModel, _httpContextAccessor.HttpContext.User.Identity.Name ?? "");
await _eventSourceRepository.AddAsync(eventSourceModel);
}
public async Task AddAsync(EventSourceModel eventSourceModel)
{
await _models.AddAsync(eventSourceModel);
_db.SaveChanges();
}
public string Render(Project project, EventSourceModel eventSource, EventModel model)
{
return(Render(model));
}
private string RenderStartOperation(Project project, ProjectItem <LoggerModel> loggerProjectItem, EventSourceModel eventSourceModel, EventModel model)
{
return(RenderMethod(project, loggerProjectItem, eventSourceModel, model));
}
