private SqlCommand CreateInsertCommand(SqlConnection connection, ScarfLogMessage message)
{
SqlCommand insertCommand = connection.CreateCommand();
insertCommand.CommandText =
@"INSERT INTO scarf_Log
( Id, LoggedAtUtc, ApplicationName, Computer, ResourceUri, [User], Class, Type, Message, LogMessageAsJson )
VALUES
( @Id, @LoggedAtUtc, @ApplicationName, @Computer, @ResourceUri, @User, @Class, @Type, @Message, @LogMessageAsJson )";
insertCommand.CommandType = System.Data.CommandType.Text;
AddParameter(insertCommand, "@Id", message.EntryId);
AddParameter(insertCommand, "@LoggedAtUtc", message.LoggedAt);
AddParameter(insertCommand, "@ApplicationName", Truncate(message.Application, 100));
AddParameter(insertCommand, "@Computer", Truncate(message.Computer, 100));
AddParameter(insertCommand, "@ResourceUri", Truncate(message.ResourceUri, 150));
AddParameter(insertCommand, "@User", Truncate(message.User, 150));
AddParameter(insertCommand, "@Class", message.MessageClass.ToString());
AddParameter(insertCommand, "@Type", Truncate(message.MessageType, 50));
AddParameter(insertCommand, "@Message", message.Message);
string messageJson = JsonConvert.SerializeObject(message);
AddParameter(insertCommand, "@LogMessageAsJson", messageJson);
return(insertCommand);
}
private void ReadAllMessagesFromReader(ICollection <ScarfLogMessage> messageList, SqlDataReader reader)
{
while (reader.Read())
{
ScarfLogMessage message = ReadMessageFromReader(reader);
messageList.Add(message);
}
}
private ScarfLogMessage LoadLogMessage(string filename)
{
string json = File.ReadAllText(filename);
ScarfLogMessage logMessage = JsonConvert.DeserializeObject <ScarfLogMessage>(json);
return(logMessage);
}
private void SaveLogMessageInternal(ScarfLogMessage message, SqlConnection connection)
{
using (SqlCommand command = CreateInsertCommand(connection, message))
{
int results = command.ExecuteNonQuery();
// TODO check for errors?
}
}
private void SaveLogMessage(ScarfLogMessage message)
{
string json = JsonConvert.SerializeObject(message, Formatting.Indented);
string filename = string.Format("{0}-{1:yyyy-MM-ddTHHmmss}-{2}.json",
message.Application,
DateTime.UtcNow,
message.EntryId.ToString("D"));
File.WriteAllText(Path.Combine(loggingFolder, filename), json);
}
public void Action()
{
using (IScarfContext context = ScarfLogging.BeginInlineContext())
{
ScarfAction.Start(MessageType.ActionCommand);
ScarfAction.SetMessage("Performed command");
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.AreEqual(MessageClass.Action, msg.MessageClass);
Assert.AreEqual(MessageType.ActionCommand, msg.MessageType);
}
public void TestAddCustomInfo()
{
using (IScarfContext context = ScarfLogging.BeginInlineContext())
{
ScarfAction.Start(MessageType.ActionPayment);
ScarfLogging.AddCustomInfo("organizationId", "5");
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.IsTrue(msg.AdditionalInfo.ContainsKey(ScarfLogMessage.AdditionalInfo_Custom));
Assert.AreEqual("5", msg.AdditionalInfo[ScarfLogMessage.AdditionalInfo_Custom]["organizationId"]);
}
public void LogoutAudit()
{
using (IScarfContext context = ScarfLogging.BeginInlineContext())
{
ScarfAudit.Start(MessageType.AuditLogout);
ScarfAudit.LoggedOut("Test");
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.AreEqual(MessageClass.Audit, msg.MessageClass);
Assert.AreEqual(MessageType.AuditLogout, msg.MessageType);
}
public void LoginAuditFailed()
{
using (IScarfContext context = ScarfLogging.BeginInlineContext())
{
ScarfAudit.Start(MessageType.AuditLogin);
ScarfAudit.Failed();
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.AreEqual(MessageClass.Audit, msg.MessageClass);
Assert.AreEqual(MessageType.AuditLogin, msg.MessageType);
Assert.AreEqual(false, msg.Success.Value);
}
public void CreateUserAudit()
{
using (IScarfContext context = ScarfLogging.BeginInlineContext())
{
ScarfAudit.Start(MessageType.AuditCreateUser);
ScarfAudit.UserCreated("Test");
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.AreEqual(MessageClass.Audit, msg.MessageClass);
Assert.AreEqual(MessageType.AuditCreateUser, msg.MessageType);
Assert.AreEqual(true, msg.Success.Value);
}
public void ResetPasswordAudit()
{
using (IScarfContext context = ScarfLogging.BeginInlineContext())
{
ScarfAudit.Start(MessageType.AuditResetPassword);
ScarfAudit.PasswordReset("Test");
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.AreEqual(MessageClass.Audit, msg.MessageClass);
Assert.AreEqual(MessageType.AuditResetPassword, msg.MessageType);
Assert.AreEqual(true, msg.Success.Value);
}
public void ExtractHttpContextInformation()
{
var httpContext1 = CreateHttpContext();
using (IScarfContext context = ScarfLogging.BeginInlineContext(httpContext1.Object))
{
context.CreateMessage(MessageClass.Action, MessageType.ActionPayment);
context.Commit();
}
ScarfLogMessage msg = dataSource.Messages.Single();
Assert.AreEqual(RequestPath, msg.ResourceUri);
Assert.AreEqual(CurrentUsername, msg.User);
Assert.AreEqual(Environment.MachineName, msg.Computer);
Assert.AreEqual(ConfigurationMocks.ApplicationName, msg.Application);
}
public ActionResult Details(Guid?id)
{
if (id.HasValue == false)
{
return(RedirectToAction("Index"));
}
ScarfDataSource dataSource = ScarfConfiguration.DataSourceFactory.CreateDataSourceInstance();
ScarfLogMessage message = dataSource.GetMessageById(id.Value);
if (message == null)
{
return(RedirectToAction("Index"));
}
return(ScarfConfiguration.ViewResultFactory.Create(this, "Details", message));
}
public ScarfLogMessage GetMessageById(Guid messageId)
{
using (var connection = new SqlConnection(GetConnectionString()))
using (SqlCommand command = CreateSingleQueryCommand(connection, messageId))
{
connection.Open();
using (SqlDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
ScarfLogMessage message = ReadMessageFromReader(reader);
return(message);
}
else
{
return(null);
}
}
}
}
public void Serialization()
{
AuditLogMessage message = new AuditLogMessage(null)
{
Application = "1",
Computer = "2",
Details = "3",
EntryId = Guid.NewGuid(),
LoggedAt = DateTime.UtcNow,
Message = "4",
MessageClass = MessageClass.Audit,
MessageType = "5",
ResourceUri = "6",
Source = "7",
Success = true,
User = "******"
};
string serializedMessage = JsonConvert.SerializeObject(message);
ScarfLogMessage message2 = JsonConvert.DeserializeObject <ScarfLogMessage>(serializedMessage);
Assert.IsNotNull(message2);
Assert.AreEqual(message.Application, message2.Application);
Assert.AreEqual(message.Computer, message2.Computer);
Assert.AreEqual(message.Details, message2.Details);
Assert.AreEqual(message.EntryId, message2.EntryId);
Assert.AreEqual(message.LoggedAt, message2.LoggedAt);
Assert.AreEqual(message.Message, message2.Message);
Assert.AreEqual(message.MessageClass, message2.MessageClass);
Assert.AreEqual(message.MessageType, message2.MessageType);
Assert.AreEqual(message.ResourceUri, message2.ResourceUri);
Assert.AreEqual(message.Source, message2.Source);
Assert.AreEqual(message.User, message2.User);
}
internal void SaveLogMessage(ScarfLogMessage message)
{
Messages.Add(message);
}
internal void SaveLogMessage(ScarfLogMessage message)
{
Messages.Add(message);
}
private ScarfLogMessage ReadMessageFromReader(SqlDataReader reader)
{
string messageClassString = reader.GetString(reader.GetOrdinal("Class"));
string messageAsJson = reader.GetString(reader.GetOrdinal("LogMessageAsJson"));
var messageClass = (MessageClass)Enum.Parse(typeof(MessageClass), messageClassString);
var message = (ScarfLogMessage)JsonConvert.DeserializeObject(messageAsJson, ScarfLogMessage.GetMessageClassClrType(messageClass));
return(message);
}
private void SaveLogMessage(ScarfLogMessage message)
{
string json = JsonConvert.SerializeObject(message, Formatting.Indented);
string filename = string.Format("{0}-{1:yyyy-MM-ddTHHmmss}-{2}.json",
message.Application,
DateTime.UtcNow,
message.EntryId.ToString("D"));
File.WriteAllText(Path.Combine(loggingFolder, filename), json);
}
