public int LogChangedValue(AspectContext context)
{
var entity = (BaseEntity)context.Method.Args[0];
Dictionary<string, EntityColumn> changedColumns = entity.GetChangedColumns();
if (changedColumns.Count == 0)
return 0;
var logContext = new LogContext {EntityName = entity.EntityName, TableName = entity.TableName};
foreach (var c in changedColumns)
{
logContext.Values.Add(c.Key, new ChangedEntityColumn(c.Value.OldValue, c.Value.CurrentValue));
}
try
{
LogManager.Instance.Write(logContext, true);
}
catch (Exception exp)
{
throw exp;
}
return changedColumns.Count;
}
public LogEntry Log(string message, LogLevel logLevel = LogLevel.Verbose, string category = null)
{
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentNullException("message");
}
var logRecord = new LogRecord
{
ID = Guid.NewGuid(),
Timestamp = DateTime.UtcNow,
Message = message,
LogLevelName = logLevel.ToString(),
LogLevelValue = (int)logLevel,
Category = category,
};
if (logLevel != LogLevel.None && logLevel >= LogLevel)
{
using (var db = new LogContext())
{
db.LogRecords.Add(logRecord);
db.SaveChangesSync();
}
}
return logRecord;
}
public void TestSetContextWithNullLogContextProperties()
{
var logContext = new LogContext(null);
var logger = new Logger();
logger.SetContext(logContext);
Assert.Equal(0, logger.Properties.Count);
}
protected virtual void LogUnauthorized(HttpActionContext actionContext, HmacResult result, Customer customer)
{
try
{
var logger = EngineContext.Current.Resolve<ILogger>();
var localization = EngineContext.Current.Resolve<ILocalizationService>();
string strResult = result.ToString();
string description = localization.GetResource("Admin.WebApi.AuthResult." + strResult, 0, false, strResult);
var logContext = new LogContext()
{
ShortMessage = localization.GetResource("Admin.WebApi.UnauthorizedRequest").FormatWith(strResult),
FullMessage = "{0}\r\n{1}".FormatWith(description, actionContext.Request.Headers.ToString()),
LogLevel = LogLevel.Warning,
Customer = customer,
HashNotFullMessage = true,
HashIpAddress = true
};
logger.InsertLog(logContext);
}
catch (Exception exc)
{
exc.Dump();
}
}
public void TreeCreated(DbCommandTreeInterceptionContext interceptionContext)
{
var dbCommandTreeKind = interceptionContext.Result.CommandTreeKind;
var context = interceptionContext.DbContexts.First();
var auditContenxt = new LogContext();
switch (dbCommandTreeKind)
{
case DbCommandTreeKind.Insert:
var addedEntries = context.ChangeTracker.Entries()
.Where(e => e.State == EntityState.Added && e.IsAttr<AuditableAttribute>())
.ToList();
foreach (var entry in addedEntries)
{
auditContenxt.ApplyAuditLog(context, entry);
}
break;
case DbCommandTreeKind.Update:
case DbCommandTreeKind.Delete:
var entries = context.ChangeTracker.Entries().Where(
e => (e.State == EntityState.Deleted || e.State == EntityState.Modified)
&& e.IsAttr<AuditableAttribute>()).ToList();
foreach (var entry in entries)
{
auditContenxt.ApplyAuditLog(context, entry);
}
break;
}
}
static void PushLog(object sender, LogContext e)
{
foreach (var appender in APPENDERS)
{
appender.Push(e);
}
}
public Result(LogContext logContext)
{
Id = Guid.NewGuid();
Json = new JObject();
Json.Add(JSonKeys.LogType, logContext.LogType);
Json.Add(JSonKeys.MachineName, System.Environment.MachineName);
Canceled = false;
MetaData = new Dictionary<string, string>();
}
/// <summary>
/// Provider interface function for logging health event
/// </summary>
/// <param name="logContext"></param>
/// <param name="eventId"></param>
/// <param name="exception"></param>
/// <param name="additionalInfo"></param>
///
internal override void LogEngineHealthEvent(LogContext logContext, int eventId, Exception exception, Dictionary<String, String> additionalInfo)
{
StringBuilder payload = new StringBuilder();
AppendException(payload, exception);
payload.AppendLine();
AppendAdditionalInfo(payload, additionalInfo);
WriteEvent(PSEventId.Engine_Health, PSChannel.Operational, PSOpcode.Exception, PSTask.ExecutePipeline, logContext, payload.ToString());
}
public void TestSetContextDoesNotSetNonPropertyKeysProperty()
{
var logContext = new LogContext();
var logger = new Logger();
logContext.Properties["k1"] = "v1";
logger.SetContext(logContext);
Assert.Equal(0, logger.Properties.Count);
Assert.Equal(null, logger.GetProperty("k1"));
}
public static void Main()
{
Database.SetInitializer(new MigrateDatabaseToLatestVersion<LogContext, Configuration>());
using (var db = new LogContext())
{
Log test = new Log() { LogDate = DateTime.Now, LogQuery = "alabala" };
db.Logs.Add(test);
db.SaveChanges();
}
}
public static void Writer(string query)
{
Database.SetInitializer(new MigrateDatabaseToLatestVersion<LogContext, Configuration>());
using (var db = new LogContext())
{
Log newLog = new Log() { LogDate = DateTime.Now, LogQuery = query };
db.Logs.Add(newLog);
db.SaveChanges();
}
}
public List<ILogEntry> GetLog(DateTime fromDate, DateTime toDate)
{
using (var lb = new LogContext())
{
var query = (from l in lb.Logs
where l.Date <= toDate && l.Date >= fromDate
select l).ToList<ILogEntry>();
return query;
}
}
public Logger(string name, ILoggingTarget target, bool isInfo = false, bool isDebug = false, bool traceAdditionalInfo = false)
{
this.Name = name;
this.loggingTarget = target;
this.isInfo = isInfo;
this.isDebug = isDebug;
this.traceAdditionalInfo = traceAdditionalInfo;
this.loggingTarget.Init(this);
Context = null;
}
//template method
public void Write(LogContext context)
{
try
{
WriteInternal(context);
}
catch
{
if (NextLogger != null)
NextLogger.Write(context);
}
}
public void OnNext(IEnumerable<StatisticEvent> value)
{
using(var context = new LogContext())
{
foreach (var statisticEvent in value)
{
context.Set<StatisticEvent>().Add(statisticEvent);
}
context.SaveChanges();
}
}
public void ReaderExecuted(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
{
// just for update and delete commands
if (command.CommandText.StartsWith("insert", StringComparison.InvariantCultureIgnoreCase))
{
var context = interceptionContext.DbContexts.First();
var entries = context.ChangeTracker.Entries().Where(e => e.State == EntityState.Added).ToList();
var auditContenxt = new LogContext();
foreach (var entry in entries)
{
auditContenxt.ApplyAuditLog(context, entry);
}
}
}
protected override void WriteInternal(LogContext context)
{
using (TextWriter tw = File.AppendText("logs.txt"))
{
//direkt context'i basarak
tw.WriteLine(DateTime.Now.ToString() + "=>" + context);
//kolonlar arasında dolaşarak
//foreach (var c in context.Values)
//{
// tw.WriteLine(DateTime.Now.ToString() + "=>" + c.ToString());
//}
tw.WriteLine("#logged!!!");
}
}
public void NonQueryExecuting(DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
{
// just for update and delete commands
if (command.CommandText.StartsWith("update", StringComparison.InvariantCultureIgnoreCase) ||
command.CommandText.StartsWith("delete", StringComparison.InvariantCultureIgnoreCase))
{
var context = interceptionContext.DbContexts.First();
var entries = context.ChangeTracker.Entries().Where(
e => e.State == EntityState.Deleted || e.State == EntityState.Modified).ToList();
var auditContenxt = new LogContext();
foreach (var entry in entries)
{
auditContenxt.ApplyAuditLog(context, entry);
}
}
}
protected override void WriteInternal(LogContext context)
{
//todo@onuar: 110812 userContext buraya taşınacak. yani login olan user'ın bilgileri
//aklımda yarım yamalak şeyler var ama henüz oturamadım.
List<BaseEntity> logEntities = new List<BaseEntity>();
foreach (var c in context.Values)
{
BaseEntity logEntity = new BaseEntity() { EntityName = "Log" };
EntityColumn ec = (EntityColumn)c.Value;
logEntity.SetValue<string>("OldValue", ConvertionHelper.ConvertValue<string>(ec.OldValue));
logEntity.SetValue<string>("NewValue", ConvertionHelper.ConvertValue<string>(ec.CurrentValue));
logEntities.Add(logEntity);
}
//todo@onuar: 110812 transaction ile database'e yazdırılacak
//entityManager ile olmuyor çünkü loggerPlugins projesi, hrc.library'i direkt referans almıyor.
//referans gösteremiyoruz çünki circleDependency hatası yiyoruz. ya dbAccessLayer dışarı alınacak ya da başka bir şey
}
private static void FillEventArgs(Hashtable mapArgs, LogContext logContext)
{
mapArgs["Severity"] = logContext.Severity;
mapArgs["SequenceNumber"] = logContext.SequenceNumber;
mapArgs["HostName"] = logContext.HostName;
mapArgs["HostVersion"] = logContext.HostVersion;
mapArgs["HostId"] = logContext.HostId;
mapArgs["EngineVersion"] = logContext.EngineVersion;
mapArgs["RunspaceId"] = logContext.RunspaceId;
mapArgs["PipelineId"] = logContext.PipelineId;
mapArgs["CommandName"] = logContext.CommandName;
mapArgs["CommandType"] = logContext.CommandType;
mapArgs["ScriptName"] = logContext.ScriptName;
mapArgs["CommandPath"] = logContext.CommandPath;
mapArgs["CommandLine"] = logContext.CommandLine;
mapArgs["User"] = logContext.User;
mapArgs["Time"] = logContext.Time;
}
public void TestClearContextClearsOnlyPropertyKeysProperties()
{
var logContext = new LogContext();
var logger = new Logger();
foreach (var propertyKeyField in LogContext.PropertyKey.Fields)
{
var propertyKey = propertyKeyField.GetValue(logContext) as string;
logContext.Properties[propertyKey] = propertyKey;
}
logger.SetContext(logContext);
logger.SetProperty("k1", "v1");
logger.ClearContext();
Assert.Equal(1, logger.Properties.Count);
Assert.Equal("v1", logger.GetProperty("k1"));
}
protected override void WriteInternal(LogContext context)
{
var logEntities = new List<BaseEntity>();
foreach (var c in context.Values)
{
BaseEntity logEntity = new BaseEntity() { EntityName = "DataLog" };
var ec = (ChangedEntityColumn)c.Value;
logEntity.SetValue<DateTime>("ModifiedDate", DateTime.Now);
logEntity.SetValue<string>("EntityName", context.EntityName);
logEntity.SetValue<string>("TableName", context.TableName);
logEntity.SetValue<string>("ColumnName", c.Key);
logEntity.SetValue<string>("OldValue", ConvertionHelper.ConvertValue<string>(ec.OldValue));
logEntity.SetValue<string>("NewValue", ConvertionHelper.ConvertValue<string>(ec.CurrentValue));
logEntities.Add(logEntity);
//todo@onuar: transaction
EntityManager.Insert(logEntity);
}
}
public void TestSetContextSetsOnlyPropertyKeys()
{
var logContext = new LogContext();
var logger = new Logger();
foreach (var propertyKeyField in LogContext.PropertyKey.Fields)
{
var propertyKey = propertyKeyField.GetValue(logContext) as string;
logContext.Properties[propertyKey] = propertyKey;
}
logger.SetContext(logContext);
Assert.Equal(logContext.Properties.Count, logger.Properties.Count);
foreach (var propertyKeyField in LogContext.PropertyKey.Fields)
{
var propertyKey = propertyKeyField.GetValue(logContext) as string;
var propertyValue = logger.GetProperty(propertyKey);
Assert.Equal(logContext.Properties[propertyValue], propertyValue);
}
}
public override void Before(MethodInfo methodUnderTest)
{
Disposables.TryAdd(methodUnderTest.Name, LogContext.PushProperty("Test", methodUnderTest.Name));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, LogContext context)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
LogContextInitializer.Initialize(context);
app.UseMvc();
}
private void LogRequestAndResponse(IRestResponse response, Stopwatch stopwatch)
{
if (this.Configuration.LoggerConfiguration != null)
{
Log.Logger = this.Configuration.LoggerConfiguration.CreateLogger();
}
var uri = this.BuildUri(response.Request);
string[] ignoredProperties = this.GetIgnoredProperties(response.Request);
var properties = new Dictionary <string, object>();
if (this.AdditionalProperties?.Any() == true)
{
foreach (var item in this.AdditionalProperties)
{
properties.Add(item.Key, item.Value);
}
}
properties.Add("Agent", "RestSharp");
properties.Add("ElapsedMilliseconds", stopwatch.ElapsedMilliseconds);
properties.Add("Method", response.Request.Method.ToString());
properties.Add("Url", uri.AbsoluteUri);
properties.Add("Host", uri.Host);
properties.Add("Path", uri.AbsolutePath);
properties.Add("Port", uri.Port);
properties.Add("QueryString", uri.Query);
properties.Add("Query", this.GetRequestQueryStringAsObject(response.Request));
properties.Add("RequestBody", this.GetRequestBody(response.Request));
properties.Add("RequestHeaders", this.GetRequestHeaders(response.Request));
properties.Add("StatusCode", (int)response.StatusCode);
properties.Add("StatusCodeFamily", ((int)response.StatusCode).ToString()[0] + "XX");
properties.Add("StatusDescription", response.StatusDescription?.Replace(" ", ""));
properties.Add("ResponseStatus", response.ResponseStatus.ToString());
properties.Add("ProtocolVersion", response.ProtocolVersion);
properties.Add("IsSuccessful", response.IsSuccessful);
properties.Add("ErrorMessage", response.ErrorMessage);
properties.Add("ErrorException", response.ErrorException);
properties.Add("ResponseContent", this.GetResponseContent(response));
properties.Add("ContentLength", response.ContentLength);
properties.Add("ContentType", response.ContentType);
properties.Add("ResponseHeaders", this.GetResponseHeaders(response));
properties.Add("Environment", Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"));
foreach (var property in properties)
{
if (ignoredProperties.Contains(property.Key) == false)
{
LogContext.PushProperty(property.Key, property.Value);
}
}
if (response.IsSuccessful)
{
Log.Information(this.Configuration.MessageTemplateForSuccess);
}
else
{
Log.Error(this.Configuration.MessageTemplateForSuccess);
}
}
/// <summary>
/// When exception occures, log it to event log.
/// </summary>
/// <param name="messageTitle">Title message</param>
/// <param name="ex">Exception to log</param>
private void LogExceptionToEventLog(string messageTitle, Exception ex)
{
AddError(messageTitle + ": " + ex.Message);
LogContext.LogEventToCurrent(EventType.ERROR, "Content", "PUBLISHDOC", EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, currentUser.UserID, currentUser.UserName, 0, null, RequestContext.UserHostAddress, currentSiteId, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
public async Task Invoke(HttpContext context)
{
using (LogContext.PushProperty("Address", context.Connection.RemoteIpAddress)) {
await _next.Invoke(context).ConfigureAwait(false);
}
}
public async Task Send(SendEndpointContext clientContext)
{
LogContext.SetCurrentIfNull(_context.LogContext);
var context = new AzureServiceBusSendContext <T>(_message, _cancellationToken);
CopyIncomingIdentifiersIfPresent(context);
await _pipe.Send(context).ConfigureAwait(false);
var activity = LogContext.IfEnabled(OperationName.Transport.Send)?.StartSendActivity(context,
(nameof(context.PartitionKey), context.PartitionKey),
(nameof(context.SessionId), context.SessionId));
try
{
if (IsCancelScheduledSend(context, out var sequenceNumber))
{
await CancelScheduledSend(clientContext, sequenceNumber).ConfigureAwait(false);
return;
}
if (context.ScheduledEnqueueTimeUtc.HasValue)
{
var scheduled = await ScheduleSend(clientContext, context).ConfigureAwait(false);
if (scheduled)
{
return;
}
}
if (_context.SendObservers.Count > 0)
{
await _context.SendObservers.PreSend(context).ConfigureAwait(false);
}
var brokeredMessage = CreateBrokeredMessage(context);
await clientContext.Send(brokeredMessage).ConfigureAwait(false);
context.LogSent();
if (_context.SendObservers.Count > 0)
{
await _context.SendObservers.PostSend(context).ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (_context.SendObservers.Count > 0)
{
await _context.SendObservers.SendFault(context, ex).ConfigureAwait(false);
}
throw;
}
finally
{
activity?.Stop();
}
}
public void Configure(
IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
IApplicationLifetime appLifetime)
{
var loggerConfiguration = new LoggerConfiguration().Enrich.FromLogContext();
if (env.IsDevelopment())
{
loggerConfiguration
.MinimumLevel.Debug()
.WriteTo.ColoredConsole();
}
else
{
loggerConfiguration.MinimumLevel.Is(LogEventLevel.Verbose);
var logGroupName = Configuration["aws:cloudwatch:logGroupName"] + "/" + env.EnvironmentName;
AWSCredentials credentials =
new BasicAWSCredentials(Configuration["aws:accessKey"], Configuration["aws:secret"]);
IAmazonCloudWatchLogs client = new AmazonCloudWatchLogsClient(credentials, RegionEndpoint.EUCentral1);
var options = new CloudWatchSinkOptions
{
LogGroupName = logGroupName,
LogEventRenderer = new JsonLogEventRenderer(),
MinimumLogEventLevel = (LogEventLevel)Convert.ToInt32(Configuration["logLevel"]),
LogStreamNameProvider = new ConstantLogStreamNameProvider(Environment.MachineName)
};
loggerConfiguration.WriteTo.AmazonCloudWatch(options, client);
}
loggerConfiguration
.WriteTo
.Logger(lc =>
lc.Filter
.ByIncludingOnly($"EventId.Id = {LogEvents.Audit.Id}")
.WriteTo.File(Configuration["auditLog"],
restrictedToMinimumLevel: LogEventLevel.Verbose,
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{IPAddress}] [{Level}] {Message}{NewLine}{Exception}"
)
);
var cgc = app.ApplicationServices.GetService <CollectionGameConfiguration>();
loggerConfiguration
.WriteTo
.Logger(lc =>
lc.Filter
.ByIncludingOnly($"EventId.Id = {LogEvents.CollectionGame.Id}")
.WriteTo.File(cgc.LogFile, (LogEventLevel)cgc.LogLevel)
);
Log.Logger = loggerConfiguration.CreateLogger();
loggerFactory
.WithFilter(new FilterLoggerSettings
{
{ "Microsoft", env.IsDevelopment() ? LogLevel.Information : LogLevel.Warning },
{ "System", env.IsDevelopment() ? LogLevel.Information : LogLevel.Warning }
})
.AddSerilog();
_logger = loggerFactory.CreateLogger(GetType());
_logger.LogInformation($"Logging commences");
appLifetime.ApplicationStopped.Register(Log.CloseAndFlush);
app.UseCors("CorsPolicy");
app.UseAuthentication();
app.Use(async(context, next) =>
{
using (LogContext.PushProperty("IPAddress",
context.Request.Headers.ContainsKey("X-Forwarded-For") ?
context.Request.Headers["X-Forwarded-For"].ToString()
: context.Connection.RemoteIpAddress.ToString()))
{
await next();
}
});
app.UseMvc(routes =>
{
routes.MapRoute(
"default",
"{controller=Test}/{action=Index}/{id?}");
});
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.RoutePrefix = "swagger/v2/ui";
c.DocExpansion(DocExpansion.None);
c.SwaggerEndpoint("/swagger/v2/swagger.json", "API v2");
c.EnableDeepLinking();
});
if (env.IsProduction())
{
_logger.LogDebug("Starting JobManager to run jobs");
JobManager.JobFactory = new ServiceProviderJobFactory(app.ApplicationServices);
JobManager.Initialize(new JobRegistry(Configuration.GetSection("jobs")));
}
_logger.LogInformation($"Startup complete ({env.EnvironmentName})");
}
private void Update()
{
if (m_ResetLog == true)
{
m_ResetLog = false;
m_LogContextMap.Clear();
m_LogListLock.EnterWriteLock();
try
{
m_LogList.Clear();
}
finally
{
m_LogListLock.ExitWriteLock();
}
}
var deletedNameSet = new HashSet <string>(m_LogContextMap.Keys);
m_LogDirectoryInfo.Refresh();
if (m_LogDirectoryInfo.Exists == true)
{
var fileInfos = m_LogDirectoryInfo.GetFiles("output_log_*.txt", SearchOption.TopDirectoryOnly);
// sort by creation time
Array.Sort(fileInfos, (a, b) => a.CreationTimeUtc.CompareTo(b.CreationTimeUtc));
var utcNow = DateTime.UtcNow;
var minLimitDateTime = utcNow.AddDays(-7d);
var minRefreshDateTime = utcNow.AddMinutes(-3d);
foreach (var fileInfo in fileInfos)
{
var lastWriteTimeUtc = fileInfo.LastWriteTimeUtc;
if (lastWriteTimeUtc < minLimitDateTime)
{
continue;
}
if (lastWriteTimeUtc >= minRefreshDateTime)
{
fileInfo.Refresh();
if (fileInfo.Exists == false)
{
continue;
}
}
if (m_LogContextMap.TryGetValue(fileInfo.Name, out LogContext logContext) == true)
{
deletedNameSet.Remove(fileInfo.Name);
}
else
{
logContext = new LogContext();
m_LogContextMap.Add(fileInfo.Name, logContext);
}
if (logContext.Length == fileInfo.Length)
{
continue;
}
logContext.Length = fileInfo.Length;
ParseLog(fileInfo, logContext);
}
}
foreach (var name in deletedNameSet)
{
m_LogContextMap.Remove(name);
}
}
/// <summary>
/// Provider interface function for logging command lifecycle event
/// </summary>
/// <param name="logContext"></param>
/// <param name="newState"></param>
///
internal static void LogCommandLifecycleEvent(LogContext logContext, CommandState newState)
{
provider.LogCommandLifecycleEvent(() => logContext, newState);
}
/// <summary>
/// Provider interface function for logging provider health event
/// </summary>
/// <param name="logContext"></param>
/// <param name="providerName"></param>
/// <param name="exception"></param>
internal static void LogProviderHealthEvent(LogContext logContext, string providerName, Exception exception)
{
provider.LogProviderHealthEvent(logContext, providerName, exception);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseMiddleware <ExceptionMiddleware>();
// Adds an IP address to your log's context.
app.Use(async(context, next) =>
{
using (LogContext.PushProperty("IPAddress", context.Connection.RemoteIpAddress))
{
await next.Invoke();
}
});
// Build your own authorization system or use Identity.
app.Use(async(context, next) =>
{
var accountService = (AccountService)context.RequestServices.GetService(typeof(AccountService));
var verifyResult = accountService.Verify(context);
if (!verifyResult.HasErrors)
{
context.Items.Add(Constants.HttpContextServiceUserItemKey, verifyResult.Value);
}
await next.Invoke();
// Do logging or other work that doesn't write to the Response.
});
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
#pragma warning disable CS0618 // Type or member is obsolete
// WebpackDevMiddleware.UseWebpackDevMiddleware(app, new WebpackDevMiddlewareOptions
// {
// HotModuleReplacement = true,
// ReactHotModuleReplacement = true
// });
#pragma warning restore CS0618 // Type or member is obsolete
}
else
{
app.UseExceptionHandler("/Main/Error");
app.UseHsts();
}
app.UseDefaultFiles();
app.UseStaticFiles();
// Write streamlined request completion events, instead of the more verbose ones from the framework.
// To use the default framework request logging instead, remove this line and set the "Microsoft"
// level in appsettings.json to "Information".
app.UseSerilogRequestLogging();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Main}/{action=Index}/{id?}");
endpoints.MapFallbackToController("Index", "Main");
});
app.UseHttpsRedirection();
}
private void RemoveWorkflow(object parameter)
{
VersionManager verMan = VersionManager.GetInstance(Tree);
TreeNode node = null;
// Custom logging
Tree.LogEvents = false;
Tree.AllowAsyncActions = false;
CanceledString = ResHelper.GetString("workflowdocuments.removingcanceled", currentCulture);
try
{
// Begin log
AddLog(ResHelper.GetString("content.preparingdocuments", currentCulture));
string where = parameter as string;
// Get the documents
DataSet documents = GetDocumentsToProcess(where);
if (!DataHelper.DataSourceIsEmpty(documents))
{
// Begin log
AddLog(ResHelper.GetString("workflowdocuments.removingwf", currentCulture));
foreach (DataTable classTable in documents.Tables)
{
foreach (DataRow nodeRow in classTable.Rows)
{
// Get the current document
string className = ValidationHelper.GetString(nodeRow["ClassName"], string.Empty);
string aliasPath = ValidationHelper.GetString(nodeRow["NodeAliasPath"], string.Empty);
string docCulture = ValidationHelper.GetString(nodeRow["DocumentCulture"], string.Empty);
string siteName = SiteInfoProvider.GetSiteName(nodeRow["NodeSiteID"].ToInteger(0));
// Get published version
node = Tree.SelectSingleNode(siteName, aliasPath, docCulture, false, className, false);
string encodedAliasPath = HTMLHelper.HTMLEncode(ValidationHelper.GetString(aliasPath, string.Empty) + " (" + node.GetValue("DocumentCulture") + ")");
// Destroy document history
verMan.DestroyDocumentHistory(node.DocumentID);
using (new CMSActionContext {
LogEvents = false
})
{
// Clear workflow
DocumentHelper.ClearWorkflowInformation(node);
node.Update();
}
// Add log record
AddLog(encodedAliasPath);
// Add record to eventlog
LogContext.LogEvent(EventType.INFORMATION, "Content", "REMOVEDOCWORKFLOW", string.Format(GetString("workflowdocuments.removeworkflowsuccess"), encodedAliasPath), RequestContext.RawURL, currentUser.UserID, currentUser.UserName, node.NodeID, node.GetDocumentName(), RequestContext.UserHostAddress, node.NodeSiteID, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
}
CurrentInfo = GetString("workflowdocuments.removecomplete");
}
else
{
AddError(ResHelper.GetString("workflowdocuments.nodocumentstoclear", currentCulture));
}
}
catch (ThreadAbortException ex)
{
if (CMSThread.Stopped(ex))
{
// When canceled
CurrentInfo = CanceledString;
}
else
{
int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID;
// Log error
LogExceptionToEventLog("REMOVEDOCWORKFLOW", "workflowdocuments.removefailed", ex, siteId);
}
}
catch (Exception ex)
{
int siteId = (node != null) ? node.NodeSiteID : SiteContext.CurrentSiteID;
// Log error
LogExceptionToEventLog("REMOVEDOCWORKFLOW", "workflowdocuments.removefailed", ex, siteId);
}
}
static void PushHeaderProperty(string headerKey, IMessageContext ctx, string loggerKey)
{
var propertyDisposer = LogContext.PushProperty(loggerKey, ctx.Headers[headerKey]);
ctx.Disposed += propertyDisposer.Dispose;
}
public async Task Send(ModelContext modelContext)
{
LogContext.SetCurrentIfNull(_context.LogContext);
await _context.ConfigureTopologyPipe.Send(modelContext).ConfigureAwait(false);
var properties = modelContext.Model.CreateBasicProperties();
var context = new BasicPublishRabbitMqSendContext <T>(properties, _context.Exchange, _message, _cancellationToken);
await _pipe.Send(context).ConfigureAwait(false);
var exchange = context.Exchange;
if (exchange.Equals(RabbitMqExchangeNames.ReplyTo))
{
if (string.IsNullOrWhiteSpace(context.RoutingKey))
{
throw new TransportException(context.DestinationAddress, "RoutingKey must be specified when sending to reply-to address");
}
exchange = "";
}
var activity = LogContext.IfEnabled(OperationName.Transport.Send)?.StartSendActivity(context);
try
{
if (_context.SendObservers.Count > 0)
{
await _context.SendObservers.PreSend(context).ConfigureAwait(false);
}
byte[] body = context.Body;
if (context.TryGetPayload(out PublishContext publishContext))
{
context.Mandatory = context.Mandatory || publishContext.Mandatory;
}
properties.Headers ??= new Dictionary <string, object>();
properties.ContentType = context.ContentType.MediaType;
properties.Headers["Content-Type"] = context.ContentType.MediaType;
SetHeaders(properties.Headers, context.Headers);
properties.Persistent = context.Durable;
if (context.MessageId.HasValue)
{
properties.MessageId = context.MessageId.ToString();
}
if (context.CorrelationId.HasValue)
{
properties.CorrelationId = context.CorrelationId.ToString();
}
if (context.TimeToLive.HasValue)
{
properties.Expiration = (context.TimeToLive > TimeSpan.Zero ? context.TimeToLive.Value : TimeSpan.FromSeconds(1)).TotalMilliseconds
.ToString("F0", CultureInfo.InvariantCulture);
}
if (context.RequestId.HasValue && (context.ResponseAddress?.AbsolutePath?.EndsWith(RabbitMqExchangeNames.ReplyTo) ?? false))
{
context.BasicProperties.ReplyTo = RabbitMqExchangeNames.ReplyTo;
}
var publishTask = modelContext.BasicPublishAsync(exchange, context.RoutingKey ?? "", context.Mandatory, context.BasicProperties, body,
context.AwaitAck);
await publishTask.OrCanceled(context.CancellationToken).ConfigureAwait(false);
context.LogSent();
if (_context.SendObservers.Count > 0)
{
await _context.SendObservers.PostSend(context).ConfigureAwait(false);
}
}
catch (Exception ex)
{
context.LogFaulted(ex);
if (_context.SendObservers.Count > 0)
{
await _context.SendObservers.SendFault(context, ex).ConfigureAwait(false);
}
throw;
}
finally
{
activity?.Stop();
}
}
private static void Main()
{
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Debug()
.WriteTo.Console()
// Other overloads exist, for example, configure the SDK with only the DSN or no parameters at all.
.WriteTo.Sentry(o =>
{
o.MinimumBreadcrumbLevel = LogEventLevel.Debug; // Debug and higher are stored as breadcrumbs (default os Information)
o.MinimumEventLevel = LogEventLevel.Error; // Error and higher is sent as event (default is Error)
// If DSN is not set, the SDK will look for an environment variable called SENTRY_DSN. If nothing is found, SDK is disabled.
o.Dsn = new Dsn("https://[email protected]/5428537");
o.AttachStacktrace = true;
o.SendDefaultPii = true; // send PII like the username of the user logged in to the device
// Other configuration
})
.CreateLogger();
try
{
// The following anonymous object gets serialized and sent with log messages
using (LogContext.PushProperty("inventory", new
{
SmallPotion = 3,
BigPotion = 0,
CheeseWheels = 512
}))
{
// Minimum Breadcrumb and Event log levels are set to levels higher than Verbose
// In this case, Verbose messages are ignored
Log.Verbose("Verbose message which is not sent.");
// Minimum Breadcrumb level is set to Debug so the following message is stored in memory
// and sent with following events of the same Scope
Log.Debug("Debug message stored as breadcrumb.");
// Sends an event and stores the message as a breadcrumb too, to be sent with any upcoming events.
Log.Error("Some event that includes the previous breadcrumbs");
try
{
DoWork();
}
catch (Exception e)
{
e.Data.Add("details", "Do work always throws.");
Log.Fatal(e, "Error: with exception");
throw;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
Log.CloseAndFlush();
}
}
public static void PushProperty <T>(string name, T propValue, bool destructureObjects = false)
{
Log.Logger.ForContext(name, propValue);
LogContext.PushProperty(name, propValue, destructureObjects);
}
/// <summary>
/// Ensures and returns the log context for the async control.
/// </summary>
private LogContext EnsureAsyncLogContext()
{
var log = LogContext.EnsureLog(ucAsync.ProcessGUID);
return(log);
}
private bool ParseLogOnPlayerJoinedOrLeft(FileInfo fileInfo, LogContext logContext, string line, int offset)
{
// 2020.10.31 23:36:58 Log - [NetworkManager] OnPlayerJoined pypy
// 2020.10.31 23:36:58 Log - [Player] Initialized PlayerAPI "pypy" is local
// 2020.10.31 23:36:58 Log - [NetworkManager] OnPlayerJoined Rize♡
// 2020.10.31 23:36:58 Log - [Player] Initialized PlayerAPI "Rize♡" is remote
// 2020.11.01 00:07:01 Log - [NetworkManager] OnPlayerLeft Rize♡
// 2020.11.01 00:07:01 Log - [PlayerManager] Removed player 2 / Rize♡
// 2020.11.01 00:07:02 Log - [Player] Unregistering Rize♡
if (string.Compare(line, offset, "Initialized PlayerAPI \"", 0, 23, StringComparison.Ordinal) == 0)
{
var pos = line.LastIndexOf("\" is ");
if (pos < 0)
{
return(false);
}
var userDisplayName = line.Substring(offset + 23, pos - (offset + 23));
var userType = line.Substring(pos + 5);
AppendLog(new[]
{
fileInfo.Name,
ConvertLogTimeToISO8601(line),
"player-joined",
userDisplayName,
userType,
});
return(true);
}
// fallback method
/*if (string.Compare(line, offset, "OnPlayerJoined ", 0, 15, StringComparison.Ordinal) == 0)
* {
* var userDisplayName = line.Substring(offset + 15);
*
* AppendLog(new[]
* {
* fileInfo.Name,
* ConvertLogTimeToISO8601(line),
* "player-joined",
* userDisplayName
* });
*
* return true;
* }*/
if (string.Compare(line, offset, "OnPlayerLeft ", 0, 13, StringComparison.Ordinal) == 0)
{
var userDisplayName = line.Substring(offset + 13);
AppendLog(new[]
{
fileInfo.Name,
ConvertLogTimeToISO8601(line),
"player-left",
userDisplayName
});
return(true);
}
return(false);
}
static void Main(string[] args)
{
var configBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
_configuration = configBuilder.Build();
var logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.ColoredConsole()
.CreateLogger();
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddSerilog(logger);
LogContext.ConfigureCurrentLogContext(loggerFactory);
var smsConfiguration = new SmsConfiguration
{
BaseUrl = _configuration["BaseUrl"],
SmsSender = _configuration["SmsSender"],
RapidProPassword = _configuration["RapidProPassword"],
RapidProUserName = _configuration["RapidProUserName"],
RapidProSmsCode = _configuration["RapidProSmsCode"]
};
var builder = new ContainerBuilder();
builder.RegisterModule(new ServiceModule(smsConfiguration));
builder.RegisterModule <ConsumersModule>();
builder.Register(context =>
{
var busControl = Bus.Factory.CreateUsingRabbitMq(config =>
{
config.ConfigureJsonSerializer(options =>
{
options.DefaultValueHandling = DefaultValueHandling.Include;
return(options);
});
var host = config.Host(new Uri(_configuration.GetValue <string>("RabbitMQHost")), h =>
{
h.Username(_configuration.GetValue <string>("RabbitMQUsername"));
h.Password(_configuration.GetValue <string>("RabbitMQPassword"));
});
config.PrefetchCount = 32;
config.UseRetry(retry => retry.Interval(3, TimeSpan.FromSeconds(6)));
config.ReceiveEndpoint(_configuration["SmsQueue"], e =>
{
e.Consumer <SmsConsumer>(context);
});
});
return(busControl);
})
.SingleInstance()
.As <IBusControl>()
.As <IBus>();
LogContext.Info?.Log("Creating Service bus..");
var container = builder.Build();
var bus = container.Resolve <IBusControl>();
bus.Start();
LogContext.Info?.Log("Bus started");
LogContext.Info?.Log("Waiting for request");
Console.ReadLine();
bus.Stop();
}
/// <summary>
/// Adds Sejil to the request pipeline.
/// </summary>
/// <param name="app">The application builder.</param>
/// <returns></returns>
public static IApplicationBuilder UseSejil(this IApplicationBuilder app)
{
var settings = (ISejilSettings)app.ApplicationServices.GetService(typeof(ISejilSettings));
var url = settings.Url.Trim('/'); //settings.Url.Substring(1); // Skip the '/'
app.Use(async(context, next) =>
{
var userName = context.User.Identity.IsAuthenticated
? context.User.Identity.Name
: context.Connection.RemoteIpAddress?.ToString() ?? "Unknown";
using (LogContext.PushProperty("Username", userName))
{
await next.Invoke();
}
});
app.UseRouter(routes =>
{
routes.MapGet(url, async context =>
{
var controller = GetSejilController(context);
await controller.GetIndexAsync();
});
routes.MapPost($"{url}/events", async context =>
{
var query = await JsonSerializer.DeserializeAsync <LogQueryFilter>(context.Request.Body, _camelCaseJson);
Int32.TryParse(context.Request.Query["page"].FirstOrDefault(), out var page);
Int32.TryParse(context.Request.Query["pageSize"].FirstOrDefault(), out var pageSize);
var dateParsed = DateTime.TryParse(context.Request.Query["startingTs"].FirstOrDefault(), out var startingTs);
var controller = GetSejilController(context);
await controller.GetEventsAsync(page, pageSize, dateParsed ? startingTs : (DateTime?)null, query);
});
routes.MapPost($"{url}/log-query", async context =>
{
var logQuery = await JsonSerializer.DeserializeAsync <LogQuery>(context.Request.Body, _camelCaseJson);
var controller = GetSejilController(context);
await controller.SaveQueryAsync(logQuery);
});
routes.MapGet($"{url}/log-queries", async context =>
{
var controller = GetSejilController(context);
await controller.GetQueriesAsync();
});
routes.MapGet($"{url}/min-log-level", async context =>
{
var controller = GetSejilController(context);
await controller.GetMinimumLogLevelAsync();
});
routes.MapGet($"{url}/user-name", async context =>
{
var controller = GetSejilController(context);
await controller.GetUserNameAsync();
});
routes.MapPost($"{url}/min-log-level", async context =>
{
var minLogLevel = await GetRequestBodyAsync(context.Request);
var controller = GetSejilController(context);
controller.SetMinimumLogLevel(minLogLevel);
});
routes.MapPost($"{url}/del-query", async context =>
{
var queryName = await GetRequestBodyAsync(context.Request);
var controller = GetSejilController(context);
await controller.DeleteQueryAsync(queryName);
});
routes.MapGet($"{url}/title", async context =>
{
var controller = GetSejilController(context);
await controller.GetTitleAsync();
});
});
return(app);
}
public HttpResponseMessage List(RequestDTO req)
{
try
{
OpenContentModuleConfig module = OpenContentModuleConfig.Create(ActiveModule, PortalSettings);
JObject reqOptions = null;
if (!string.IsNullOrEmpty(req.options))
{
reqOptions = JObject.Parse(req.options);
}
if (module.IsListMode())
{
var indexConfig = OpenContentUtils.GetIndexConfig(module.Settings.Template);
QueryBuilder queryBuilder = new QueryBuilder(indexConfig);
bool isEditable = module.ViewModule.CheckIfEditable(module);
queryBuilder.Build(module.Settings.Query, !isEditable, UserInfo.UserID, DnnLanguageUtils.GetCurrentCultureCode(), UserInfo.Social.Roles.FromDnnRoles());
JplistQueryBuilder.MergeJpListQuery(indexConfig, queryBuilder.Select, req.StatusLst, DnnLanguageUtils.GetCurrentCultureCode());
IDataItems dsItems;
if (queryBuilder.DefaultNoResults && queryBuilder.Select.IsEmptyQuery)
{
dsItems = new DefaultDataItems()
{
Items = new List <DefaultDataItem>(),
Total = 0
};
}
else
{
IDataSource ds = DataSourceManager.GetDataSource(module.Settings.Manifest.DataSource);
var dsContext = OpenContentUtils.CreateDataContext(module, UserInfo.UserID, false, reqOptions);
dsItems = ds.GetAll(dsContext, queryBuilder.Select);
}
var mf = new ModelFactoryMultiple(dsItems.Items, module);
mf.Options = reqOptions;
var model = mf.GetModelAsJson(false, req.onlyItems);
//model["luceneQuery"] = dsItems.DebugInfo;
if (LogContext.IsLogActive)
{
LogContext.Log(ActiveModule.ModuleID, "RequestContext", "IsEditable", isEditable);
LogContext.Log(ActiveModule.ModuleID, "RequestContext", "UserRoles", PortalSettings.UserInfo.Social.Roles.Select(r => r.RoleName));
LogContext.Log(ActiveModule.ModuleID, "RequestContext", "CurrentUserId", PortalSettings.UserId);
var logKey = "Query";
LogContext.Log(ActiveModule.ModuleID, logKey, "select", queryBuilder.Select);
LogContext.Log(ActiveModule.ModuleID, logKey, "debuginfo", dsItems.DebugInfo);
LogContext.Log(ActiveModule.ModuleID, logKey, "model", model);
model["Logs"] = JToken.FromObject(LogContext.Current.ModuleLogs(ActiveModule.ModuleID));
}
var res = new ResultDTO()
{
data = model,
count = dsItems.Total
};
return(Request.CreateResponse(HttpStatusCode.OK, res));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "not supported because not in multi items template "));
}
}
catch (Exception exc)
{
App.Services.Logger.Error(exc);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc));
}
}
protected override void InternalExecute()
{
if (_config == null)
{
throw new Exception("You must call Configure() first");
}
var workItemServer = Engine.Source.GetService <WorkItemServer>();
workItemLinkEnricher = Services.GetRequiredService <WorkItemLinkEnricher>();
attachmentEnricher = new AttachmentMigrationEnricher(workItemServer, _config.AttachmentWorkingPath, _config.AttachmentMaxSize);
embededImagesEnricher = new EmbededImagesRepairEnricher();
gitRepositoryEnricher = new GitRepositoryEnricher(Engine);
nodeStructureEnricher = new NodeStructureEnricher(Engine);
VssClientCredentials adoCreds = new VssClientCredentials();
_witClient = new WorkItemTrackingHttpClient(Engine.Target.Config.Collection, adoCreds);
//Validation: make sure that the ReflectedWorkItemId field name specified in the config exists in the target process, preferably on each work item type.
ConfigValidation();
PopulateIgnoreList();
nodeStructureEnricher.MigrateAllNodeStructures(_config.PrefixProjectToNodes, _config.NodeBasePaths);
var stopwatch = Stopwatch.StartNew();
//////////////////////////////////////////////////
string sourceQuery =
string.Format(
@"SELECT [System.Id], [System.Tags] FROM WorkItems WHERE [System.TeamProject] = @TeamProject {0} ORDER BY {1}",
_config.WIQLQueryBit, _config.WIQLOrderBit);
var sourceWorkItems = Engine.Source.WorkItems.GetWorkItems(sourceQuery);
contextLog.Information("Replay all revisions of {sourceWorkItemsCount} work items?", sourceWorkItems.Count);
//////////////////////////////////////////////////
contextLog.Information("Found target project as {@destProject}", Engine.Target.WorkItems.Project.Name);
//////////////////////////////////////////////////////////FilterCompletedByQuery
if (_config.FilterWorkItemsThatAlreadyExistInTarget)
{
sourceWorkItems = FilterWorkItemsThatAlreadyExistInTarget(sourceWorkItems);
}
//////////////////////////////////////////////////
_current = 1;
_count = sourceWorkItems.Count;
_elapsedms = 0;
_totalWorkItem = sourceWorkItems.Count;
foreach (WorkItemData sourceWorkItemData in sourceWorkItems)
{
var sourceWorkItem = sourceWorkItemData.ToWorkItem();
workItemLog = contextLog.ForContext("SourceWorkItemId", sourceWorkItem.Id);
using (LogContext.PushProperty("sourceWorkItemTypeName", sourceWorkItem.Type.Name))
using (LogContext.PushProperty("currentWorkItem", _current))
using (LogContext.PushProperty("totalWorkItems", _totalWorkItem))
using (LogContext.PushProperty("sourceWorkItemId", sourceWorkItem.Id))
using (LogContext.PushProperty("sourceRevisionInt", sourceWorkItem.Revision))
using (LogContext.PushProperty("targetWorkItemId", null))
{
ProcessWorkItem(sourceWorkItemData, _config.WorkItemCreateRetryLimit);
if (_config.PauseAfterEachWorkItem)
{
Console.WriteLine("Do you want to continue? (y/n)");
if (Console.ReadKey().Key != ConsoleKey.Y)
{
workItemLog.Warning("USER ABORTED");
break;
}
}
}
}
//////////////////////////////////////////////////
stopwatch.Stop();
contextLog.Information("DONE in {Elapsed}", stopwatch.Elapsed.ToString("c"));
}
protected static void BaseClassInitialize(TestContext testContext)
{
_testClassContext = LogContext.PushProperty("TestClass", testContext.FullyQualifiedTestClassName);
}
async Task IBrokeredMessageReceiver.Handle(Message message, Action <ReceiveContext> contextCallback)
{
LogContext.Current = _context.LogContext;
var context = new ServiceBusReceiveContext(message, _context);
contextCallback?.Invoke(context);
context.TryGetPayload <MessageLockContext>(out var lockContext);
var activity = LogContext.IfEnabled(OperationName.Transport.Receive)?.StartReceiveActivity(context);
try
{
if (_context.ReceiveObservers.Count > 0)
{
await _context.ReceiveObservers.PreReceive(context).ConfigureAwait(false);
}
if (message.SystemProperties.LockedUntilUtc <= DateTime.UtcNow)
{
throw new MessageLockExpiredException(_inputAddress, $"The message lock expired: {message.MessageId}");
}
if (message.ExpiresAtUtc < DateTime.UtcNow)
{
throw new MessageTimeToLiveExpiredException(_inputAddress, $"The message TTL expired: {message.MessageId}");
}
await _context.ReceivePipe.Send(context).ConfigureAwait(false);
await context.ReceiveCompleted.ConfigureAwait(false);
if (lockContext != null)
{
await lockContext.Complete().ConfigureAwait(false);
}
if (_context.ReceiveObservers.Count > 0)
{
await _context.ReceiveObservers.PostReceive(context).ConfigureAwait(false);
}
}
catch (SessionLockLostException ex)
{
LogContext.Warning?.Log(ex, "Session Lock Lost: {MessageId}", message.MessageId);
if (_context.ReceiveObservers.Count > 0)
{
await _context.ReceiveObservers.ReceiveFault(context, ex).ConfigureAwait(false);
}
}
catch (MessageLockLostException ex)
{
LogContext.Warning?.Log(ex, "Session Lock Lost: {MessageId}", message.MessageId);
if (_context.ReceiveObservers.Count > 0)
{
await _context.ReceiveObservers.ReceiveFault(context, ex).ConfigureAwait(false);
}
}
catch (Exception ex)
{
if (_context.ReceiveObservers.Count > 0)
{
await _context.ReceiveObservers.ReceiveFault(context, ex).ConfigureAwait(false);
}
if (lockContext == null)
{
throw;
}
try
{
await lockContext.Abandon(ex).ConfigureAwait(false);
}
catch (Exception exception)
{
LogContext.Warning?.Log(exception, "Abandon message faulted: {MessageId}", message.MessageId);
}
}
finally
{
activity?.Stop();
context.Dispose();
}
}
/// <summary>
/// Refreshes the security parameters in macros for all the objects of the specified object types.
/// Signs all the macros with the current user if the old salt is not specified.
/// </summary>
/// <param name="objectTypes">Object types</param>
/// <param name="oldSalt">Old salt </param>
/// <param name="newSalt">New salt</param>
private void RefreshSecurityParams(IEnumerable <string> objectTypes, string oldSalt, string newSalt)
{
var oldSaltSpecified = !string.IsNullOrEmpty(oldSalt) && !chkRefreshAll.Checked;
var newSaltSpecified = !string.IsNullOrEmpty(newSalt) && !chkUseCurrentSalt.Checked;
processedObjects.Clear();
using (CMSActionContext context = new CMSActionContext())
{
context.LogEvents = false;
context.LogSynchronization = false;
foreach (var objectType in objectTypes)
{
var objectTypeResourceKey = TypeHelper.GetObjectTypeResourceKey(objectType);
var niceObjectType = GetString(objectTypeResourceKey);
if (niceObjectType == objectTypeResourceKey)
{
if (objectType.StartsWithCSafe("bizformitem.bizform.", true))
{
DataClassInfo dci = DataClassInfoProvider.GetDataClassInfo(objectType.Substring("bizformitem.".Length));
if (dci != null)
{
niceObjectType = "on-line form " + dci.ClassDisplayName;
}
}
else
{
niceObjectType = objectType;
}
}
LogContext.AppendLine(string.Format(GetString("macros.refreshsecurityparams.processing"), niceObjectType));
try
{
var infos = new InfoObjectCollection(objectType);
foreach (var info in infos)
{
try
{
bool refreshed = false;
if (oldSaltSpecified)
{
refreshed = MacroSecurityProcessor.RefreshSecurityParameters(info, oldSalt, newSaltSpecified ? newSalt : ValidationHelper.HashStringSalt, true);
}
else
{
if (chkRefreshAll.Checked && newSaltSpecified)
{
// Do not check integrity, but use new salt
refreshed = MacroSecurityProcessor.RefreshSecurityParameters(info, MembershipContext.AuthenticatedUser.UserName, true, newSalt);
}
else
{
// Do not check integrity, sign everything with current user
refreshed = MacroSecurityProcessor.RefreshSecurityParameters(info, MembershipContext.AuthenticatedUser.UserName, true);
}
}
if (refreshed)
{
var objectName = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(info.Generalized.ObjectDisplayName));
processedObjects.Add(niceObjectType, objectName);
}
}
catch (Exception ex)
{
string message = "Signing " + TypeHelper.GetNiceObjectTypeName(info.ObjectType) + " " + info.Generalized.ObjectDisplayName + " failed: " + ex.Message;
EventLogProvider.LogEvent(EventType.ERROR, "Import", "MACROSECURITY", message);
}
}
}
catch (Exception e)
{
LogContext.AppendLine(e.Message);
EventLogProvider.LogException(EVENTLOG_SOURCE_REFRESHSECURITYPARAMS, "ERROR", e);
}
}
}
EventLogProvider.LogEvent(EventType.INFORMATION, EVENTLOG_SOURCE_REFRESHSECURITYPARAMS, "PROCESSEDOBJECTS", eventDescription: GetProcessedObjectsForEventLog());
}
/// <summary>
/// Provider interface function for logging engine lifecycle event
/// </summary>
/// <param name="logContext"></param>
/// <param name="newState"></param>
/// <param name="previousState"></param>
///
internal static void LogEngineLifecycleEvent(LogContext logContext, EngineState newState, EngineState previousState)
{
provider.LogEngineLifecycleEvent(logContext, newState, previousState);
}
/// <summary>
/// When exception occurs, log it to event log.
/// </summary>
/// <param name="eventCode">Code of event</param>
/// <param name="errorTitle">Message to log to asynchronous log</param>
/// <param name="ex">Exception to log</param>
/// <param name="siteId">ID of site</param>
private void LogExceptionToEventLog(string eventCode, string errorTitle, Exception ex, int siteId)
{
AddError(ResHelper.GetString(errorTitle, currentCulture) + ": " + ex.Message);
LogContext.LogEvent(EventType.ERROR, "Content", eventCode, EventLogProvider.GetExceptionLogMessage(ex), RequestContext.RawURL, currentUser.UserID, currentUser.UserName, 0, null, RequestContext.UserHostAddress, siteId, SystemContext.MachineName, RequestContext.URLReferrer, RequestContext.UserAgent, DateTime.Now);
}
/// <summary>
/// Log context and exception
/// </summary>
/// <param name="context"></param>
/// <param name="exception"></param>
public void LogData(NancyContext context, Exception exception)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var statusCode = context.GetStatusCode(exception);
string exceptionMessage = null;
string exceptionStackTrace = null;
if (exception != null)
{
exceptionMessage = HandleFieldSize(exception.Message, ExceptionMaxLenghtExtension.ErrorMessageLenght);
exceptionStackTrace = HandleFieldSize(exception.StackTrace, ExceptionMaxLenghtExtension.ErrorExceptionLenght);
}
object controller = "Unknow";
object action = "Unknow";
if (context.Items != null)
{
context.Items.TryGetValue("Controller", out controller);
context.Items.TryGetValue("Action", out action);
}
LogContext.PushProperty("RequestBody", context.GetRequestBody(this.NancySerilogConfiguration.Blacklist));
LogContext.PushProperty("Method", context.Request.Method);
LogContext.PushProperty("Path", context.Request.Path);
LogContext.PushProperty("Host", context.Request.Url.HostName);
LogContext.PushProperty("Port", context.Request.Url.Port);
LogContext.PushProperty("Url", context.Request.Url);
LogContext.PushProperty("QueryString", context.Request.Url.Query);
LogContext.PushProperty("Query", context.GetQueryString());
LogContext.PushProperty("RequestHeaders", context.GetRequestHeaders());
LogContext.PushProperty("Ip", context.GetIp());
LogContext.PushProperty("IsSuccessful", statusCode < 400);
LogContext.PushProperty("StatusCode", statusCode);
LogContext.PushProperty("StatusDescription", ((HttpStatusCode)statusCode).ToString());
LogContext.PushProperty("StatusCodeFamily", context.GetStatusCodeFamily(exception));
LogContext.PushProperty("ProtocolVersion", context.Request.ProtocolVersion);
LogContext.PushProperty("ErrorException", exceptionStackTrace);
LogContext.PushProperty("ErrorMessage", exceptionMessage);
LogContext.PushProperty("ResponseContent", context.GetResponseContent());
LogContext.PushProperty("ContentType", context.Response.ContentType);
LogContext.PushProperty("ContentLength", context.GetResponseLength());
LogContext.PushProperty("ResponseHeaders", context.GetResponseHeaders());
LogContext.PushProperty("ElapsedMilliseconds", context.GetExecutionTime());
LogContext.PushProperty("Version", this.NancySerilogConfiguration.Version);
LogContext.PushProperty("RequestKey", context.GetRequestKey());
LogContext.PushProperty("Controller", controller?.ToString());
LogContext.PushProperty("Operation", action?.ToString());
LogContext.PushProperty("Environment", Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"));
if (context.Items.ContainsKey("NancySerilogAdditionalInfo"))
{
var additionalInfo = (AdditionalInfo)context.Items["NancySerilogAdditionalInfo"];
if (additionalInfo?.Data != null)
{
foreach (var item in additionalInfo.Data)
{
LogContext.PushProperty(item.Key, item.Value);
}
}
}
if (exception != null || statusCode >= 500)
{
var errorTitle = this.NancySerilogConfiguration.ErrorTitle ?? DefaultErrorTitle;
this.NancySerilogConfiguration.Logger.Error(errorTitle);
}
else
{
var informationTitle = this.NancySerilogConfiguration.InformationTitle ?? DefaultInformationTitle;
this.NancySerilogConfiguration.Logger.Information(informationTitle);
}
}
public static void EnrichWithHttpRequest(this ILogger log, HttpRequest request)
{
LogContext.PushProperty(RequestConstants.CorrelationId, request.CorrelationId());
LogContext.PushProperty(RequestConstants.CausationId, request.CausationId());
LogContext.PushProperty(RequestConstants.RequestId, request.RequestId());
}
/// <summary>
/// Provider interface function for logging health event
/// </summary>
/// <param name="logContext"></param>
/// <param name="eventId"></param>
/// <param name="exception"></param>
/// <param name="additionalInfo"></param>
///
internal static void LogEngineHealthEvent(LogContext logContext, int eventId, Exception exception, Dictionary<String, String> additionalInfo)
{
provider.LogEngineHealthEvent(logContext, eventId, exception, additionalInfo);
}
public LogRepository(LogContext context)
{
_context = context;
}
/// <summary>
/// Provider interface function for logging command health event
/// </summary>
/// <param name="logContext"></param>
/// <param name="exception"></param>
internal static void LogCommandHealthEvent(LogContext logContext, Exception exception)
{
provider.LogCommandHealthEvent(logContext, exception);
}
/// <summary>
/// Writes a single event.
/// </summary>
/// <param name="id">Event id.</param>
/// <param name="channel"></param>
/// <param name="opcode"></param>
/// <param name="task"></param>
/// <param name="logContext">Log context.</param>
/// <param name="payLoad"></param>
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad)
{
WriteEvent(id, channel, opcode, GetPSLevelFromSeverity(logContext.Severity), task, (PSKeyword)0x0,
LogContextToString(logContext), GetPSLogUserData(logContext.ExecutionContext), payLoad);
}
/// <summary>
/// Provider interface function for logging pipeline execution detail.
/// </summary>
/// <param name="logContext"></param>
/// <param name="pipelineExecutionDetail"></param>
internal static void LogPipelineExecutionDetailEvent(LogContext logContext, List<String> pipelineExecutionDetail)
{
provider.LogPipelineExecutionDetailEvent(logContext, pipelineExecutionDetail);
}
/// <summary>
/// Provider interface function for logging provider health event
/// </summary>
/// <param name="logContext"></param>
/// <param name="providerName"></param>
/// <param name="exception"></param>
internal static void LogProviderHealthEvent(LogContext logContext, string providerName, Exception exception)
{
provider.LogProviderHealthEvent(logContext, providerName, exception);
}
/// <summary>
/// Provider interface function for logging provider lifecycle event
/// </summary>
/// <param name="logContext"></param>
/// <param name="providerName"></param>
/// <param name="newState"></param>
///
internal static void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState)
{
provider.LogProviderLifecycleEvent(logContext, providerName, newState);
}
/// <summary>
/// Provider interface function for logging provider lifecycle event
/// </summary>
/// <param name="logContext"></param>
/// <param name="providerName"></param>
/// <param name="newState"></param>
///
internal static void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState)
{
provider.LogProviderLifecycleEvent(logContext, providerName, newState);
}
