public List <Report> GetAll()
{
List <Report> reports = new List <Report>();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT Report.Id,Report.SiteTitle,Ban.[Name],Report.[DateTime] FROM Ban INNER JOIN Report ON (Ban.Id=Report.BanID)", connection);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
reports.Add(new Report()
{
Id = (int)sqlDataReader["Id"],
SiteTitle = sqlDataReader["SiteTitle"].ToString(),
DateTime = (DateTime)sqlDataReader["DateTime"],
Ban = new Ban()
{
Name = sqlDataReader["Name"].ToString()
}
});
}
connection.Close();
return(reports);
}
}
public IUnitOfWork BeginUnitOfWork(SqlConnectionType connectiontype, SqlIsolationLevel isolationLevel, string feature)
{
SqlConnection sqlConnection = SqlConnectionContext.GetDBConnection();//Unopened
var isReadonlyConnection = connectiontype == SqlConnectionType.UseReadOnlyDatabase;
var myDbContext = new MyDbContext(sqlConnection, isReadonlyConnection);
return(new EntityUnitOfWork(myDbContext));
}
public bool Delete(int id)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"DELETE FROM [Report] WHERE Id= @reportId", connection);
sqlCommand.Parameters.AddWithValue("@reportId", id);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Add(Mail mail)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"INSERT INTO [Mail] VALUES(@adress)", connection);
sqlCommand.Parameters.AddWithValue("@adress", mail.Adress);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Add(Ban ban)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"INSERT INTO [Ban] VALUES(@name)", connection);
sqlCommand.Parameters.AddWithValue("@name", ban.Name);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Delete(Mail mail)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"DELETE FROM [Mail] WHERE Id = @id", connection);
sqlCommand.Parameters.AddWithValue("@id", mail.Id);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Add(Report report)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"INSERT INTO [Report] VALUES (@siteTitle,@dateTime,@banId)", connection);
sqlCommand.Parameters.AddWithValue("@siteTitle", report.SiteTitle);
sqlCommand.Parameters.AddWithValue("@dateTime", report.DateTime);
sqlCommand.Parameters.AddWithValue("@banId", report.BanID);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Update(Report report)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"UPDATE [Report] SET SiteTitle=@siteTitle,DateTime=@dateTime WHERE Id= @reportId", connection);
sqlCommand.Parameters.AddWithValue("@siteTitle", report.SiteTitle);
sqlCommand.Parameters.AddWithValue("@dateTime", report.DateTime);
sqlCommand.Parameters.AddWithValue("@reportId", report.Id);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Update(Ban ban)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"UPDATE [Ban] SET Name=@name WHERE Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@name", ban.Name);
sqlCommand.Parameters.AddWithValue("@id", ban.Id);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Update(Mail mail)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"UPDATE [Mail] SET Adress=@adress WHERE Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@adress", mail.Adress);
sqlCommand.Parameters.AddWithValue("@id", mail.Id);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public static IUnitOfWork GetOpenEntityUnitOfWork()
{
var unitOfWork = (EntityUnitOfWork)WebCallContext.GetData(WebCallContextKey);
SqlConnectionContext.GetOpenSqlConnection();
if (unitOfWork.Context.TransactionSet == false)//Workaround to check if transaction is opened.
{
unitOfWork.Context.Database.UseTransaction(SqlConnectionContext.GetTransaction());
unitOfWork.Context.TransactionSet = true;
}
return(unitOfWork);
}
public bool Add(User user)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"INSERT INTO [User] VALUES(@name,@password)", connection);
sqlCommand.Parameters.AddWithValue("@name", user.Name);
sqlCommand.Parameters.AddWithValue("@password", user.Password);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public bool Update(User user)
{
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"UPDATE [User] SET Name=@name,Password=@password WHERE Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@name", user.Name);
sqlCommand.Parameters.AddWithValue("@password", user.Password);
sqlCommand.Parameters.AddWithValue("@id", user.Id);
int result = sqlCommand.ExecuteNonQuery();
connection.Close();
return(result > 0);
}
}
public Ban Get(int id)
{
Ban ban = new Ban();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM [Ban] WHERE Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@id", id);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
if (sqlDataReader.Read())
{
ban.Id = (int)sqlDataReader[0];
ban.Name = sqlDataReader.ToString();
}
connection.Close();
return(ban);
}
}
public Mail Get(int id)
{
Mail mail = new Mail();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM [Mail] WHERE Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@id", id);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
if (sqlDataReader.Read())
{
mail.Id = (int)sqlDataReader["Id"];
mail.Adress = sqlDataReader.ToString();
}
connection.Close();
return(mail);
}
}
public List <Mail> GetAll()
{
List <Mail> mails = new List <Mail>();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM Mail", connection);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
mails.Add(new Mail()
{
Id = (int)sqlDataReader["Id"],
Adress = sqlDataReader["Adress"].ToString()
});
}
connection.Close();
return(mails);
}
}
public List <Ban> GetAll()
{
List <Ban> bans = new List <Ban>();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM Ban", connection);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
bans.Add(new Ban()
{
Id = (int)sqlDataReader["Id"],
Name = sqlDataReader["Name"].ToString()
});
}
connection.Close();
return(bans);
}
}
public User Get(int id)
{
User user = new User();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM [User] WHERE Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@id", id);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
if (sqlDataReader.Read())
{
user.Id = sqlDataReader.GetInt32(0);
user.Name = sqlDataReader.GetString(1);
user.Password = sqlDataReader.GetString(2);
}
connection.Close();
return(user);
}
}
public List <User> GetAll()
{
List <User> users = new List <User>();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT * FROM [User]", connection);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
users.Add(new User()
{
Id = sqlDataReader.GetInt32(0),
Name = sqlDataReader.GetString(1),
Password = sqlDataReader.GetString(2)
});
}
connection.Close();
return(users);
}
}
public Report Get(int id)
{
Report report = new Report();
using (var connection = SqlConnectionContext.Connection())
{
SqlCommand sqlCommand = new SqlCommand(@"SELECT Report.Id,Report.SiteTitle,Ban.[Name],Report.[DateTime] FROM Ban INNER JOIN Report ON (Ban.Id=Report.BanID) WHERE Report.Id=@id", connection);
sqlCommand.Parameters.AddWithValue("@id", id);
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
if (sqlDataReader.Read())
{
report.Id = (int)sqlDataReader["Id"];
report.SiteTitle = sqlDataReader["SiteTitle"].ToString();
report.DateTime = (DateTime)sqlDataReader["DateTime"];
report.Ban = new Ban()
{
Name = sqlDataReader["Name"].ToString()
};
}
connection.Close();
return(report);
}
}
/// <summary>
/// Logs all name/value pairs as a single collection using concurrent MERGE statements.
/// </summary>
/// <param name="conn"></param>
/// <param name="exCollectionID"></param>
/// <param name="coll"></param>
/// <returns></returns>
async Task LogCollection(SqlConnectionContext conn, SHA1Hash exCollectionID, IDictionary<string, string> coll)
{
// The exCollectionID should be pre-calculated by `CalcCollectionID`.
// Check if the exCollectionID exists already:
int? collectionCount = await conn.ExecReader(
@"SELECT COUNT(exCollectionID) FROM [dbo].[exCollectionKeyValue] WHERE [exCollectionID] = @exCollectionID",
prms =>
prms.AddInParamSHA1("@exCollectionID", exCollectionID),
async dr => await dr.ReadAsync() ? dr.GetInt32(0) : (int?)null
);
// Don't bother logging name-value pairs if the collection already exists:
if (!collectionCount.HasValue) return;
if (collectionCount.Value == coll.Count) return;
const int numTasksPerPair = 2;
// Create an array of tasks to wait upon:
var tasks = new Task[coll.Count * numTasksPerPair];
// Fill out the array of tasks with concurrent MERGE statements for each name/value pair:
using (var en = coll.Keys.GetEnumerator())
for (int i = 0; en.MoveNext(); ++i)
{
string name = en.Current;
string value = coll[name];
var exCollectionValueID = Hash.SHA1(value);
// Merge the Value record:
tasks[i * numTasksPerPair + 0] = conn.ExecNonQuery(
@"MERGE [dbo].[exCollectionValue] WITH (HOLDLOCK) AS target
USING (SELECT @exCollectionValueID) AS source (exCollectionValueID)
ON (target.exCollectionValueID = source.exCollectionValueID)
WHEN NOT MATCHED THEN
INSERT ([exCollectionValueID], [Value])
VALUES (@exCollectionValueID, @Value );",
prms =>
prms.AddInParamSHA1("@exCollectionValueID", exCollectionValueID)
.AddInParamSize("@Value", SqlDbType.VarChar, -1, value)
);
// Merge the Name-Value record:
tasks[i * numTasksPerPair + 1] = conn.ExecNonQuery(
@"MERGE [dbo].[exCollectionKeyValue] WITH (HOLDLOCK) AS target
USING (SELECT @exCollectionID, @Name, @exCollectionValueID) AS source (exCollectionID, Name, exCollectionValueID)
ON (target.exCollectionID = source.exCollectionID AND target.Name = source.Name AND target.exCollectionValueID = source.exCollectionValueID)
WHEN NOT MATCHED THEN
INSERT ([exCollectionID], [Name], [exCollectionValueID])
VALUES (@exCollectionID, @Name, @exCollectionValueID );",
prms =>
prms.AddInParamSHA1("@exCollectionID", exCollectionID)
.AddInParamSize("@Name", SqlDbType.VarChar, 96, name)
.AddInParamSHA1("@exCollectionValueID", exCollectionValueID)
);
}
// Our final task's completion depends on all the tasks created thus far:
await Task.WhenAll(tasks);
}
/// <summary>
/// Writes a URL with query-string to the exURLQuery table.
/// </summary>
/// <param name="conn"></param>
/// <param name="uri"></param>
/// <returns></returns>
async Task LogURLQuery(SqlConnectionContext conn, Uri uri)
{
// Log the base URL:
var urlID = CalcURLID(uri);
// Compute the URLQueryID:
var urlQueryID = CalcURLQueryID(uri);
// Store the exURL record:
var tskLogURL = LogURL(conn, uri);
// Store the exURLQuery record:
var tskLogURLQuery = conn.ExecNonQuery(
@"MERGE [dbo].[exURLQuery] WITH (HOLDLOCK) AS target
USING (SELECT @exURLQueryID) AS source (exURLQueryID)
ON (target.exURLQueryID = source.exURLQueryID)
WHEN NOT MATCHED THEN
INSERT ([exURLQueryID], [exURLID], [QueryString])
VALUES (@exURLQueryID, @exURLID, @QueryString);",
prms =>
prms.AddInParamSHA1("@exURLQueryID", urlQueryID)
.AddInParamSHA1("@exURLID", urlID)
.AddInParamSize("@QueryString", SqlDbType.VarChar, -1, uri.Query)
);
await Task.WhenAll(tskLogURLQuery, tskLogURL);
}
/// <summary>
/// Writes a URL without query-string to the exURL table.
/// </summary>
/// <param name="conn"></param>
/// <param name="uri"></param>
/// <returns></returns>
Task LogURL(SqlConnectionContext conn, Uri uri)
{
var urlID = CalcURLID(uri);
return conn.ExecNonQuery(
@"MERGE [dbo].[exURL] WITH (HOLDLOCK) AS target
USING (SELECT @exURLID) AS source (exURLID)
ON (target.exURLID = source.exURLID)
WHEN NOT MATCHED THEN
INSERT ([exURLID], [HostName], [PortNumber], [AbsolutePath], [Scheme])
VALUES (@exURLID, @HostName, @PortNumber, @AbsolutePath, @Scheme );",
prms =>
prms.AddInParamSHA1("@exURLID", urlID)
.AddInParamSize("@HostName", SqlDbType.VarChar, 128, uri.Host)
.AddInParam("@PortNumber", SqlDbType.Int, (int)uri.Port)
.AddInParamSize("@AbsolutePath", SqlDbType.VarChar, 512, uri.AbsolutePath)
.AddInParamSize("@Scheme", SqlDbType.VarChar, 8, uri.Scheme)
);
}
async Task LogWebContext(SqlConnectionContext conn, ExceptionPolicy policy, ExceptionWithCapturedContext ctx, int exInstanceID)
{
var http = ctx.CapturedHttpContext;
var host = ctx.WebHostingContext;
// We require both HTTP and Host context:
if (http == null || host == null)
return;
// Try to get the authenticated user for the HTTP context:
string authUserName = null;
if (http.User != null && http.User.Identity != null)
authUserName = http.User.Identity.Name;
// Compute the IDs:
var requestURLQueryID = CalcURLQueryID(http.Url);
var referrerURLQueryID = http.UrlReferrer == null ? (SHA1Hash?)null : CalcURLQueryID(http.UrlReferrer);
var exWebApplicationID = CalcWebApplicationID(host);
// Log the web application details:
var tskWebApplication = conn.ExecNonQuery(
@"MERGE [dbo].[exWebApplication] WITH (HOLDLOCK) AS target
USING (SELECT @exWebApplicationID) AS source (exWebApplicationID)
ON (target.exWebApplicationID = source.exWebApplicationID)
WHEN NOT MATCHED THEN
INSERT ([exWebApplicationID], [MachineName], [ApplicationID], [PhysicalPath], [VirtualPath], [SiteName])
VALUES (@exWebApplicationID, @MachineName, @ApplicationID, @PhysicalPath, @VirtualPath, @SiteName );",
prms =>
prms.AddInParamSHA1("@exWebApplicationID", exWebApplicationID)
.AddInParamSize("@MachineName", SqlDbType.NVarChar, 96, host.MachineName)
.AddInParamSize("@ApplicationID", SqlDbType.VarChar, 96, host.ApplicationID)
.AddInParamSize("@PhysicalPath", SqlDbType.NVarChar, 256, host.PhysicalPath)
.AddInParamSize("@VirtualPath", SqlDbType.NVarChar, 256, host.VirtualPath)
.AddInParamSize("@SiteName", SqlDbType.VarChar, 96, host.SiteName)
);
// Log the request headers collection, if requested and available:
Task tskCollection = null;
SHA1Hash? exCollectionID = null;
if (policy.LogWebRequestHeaders && http.Headers != null)
{
var tmpDict = new NameValueCollectionDictionary(http.Headers);
// Compute the collection hash (must be done BEFORE `tskContextWeb`):
exCollectionID = CalcCollectionID(tmpDict);
// Store all records for the headers collection:
tskCollection = LogCollection(conn, exCollectionID.Value, tmpDict);
}
// Log the web context:
var tskContextWeb = conn.ExecNonQuery(
@"INSERT INTO [dbo].[exContextWeb]
([exInstanceID], [exWebApplicationID], [AuthenticatedUserName], [HttpVerb], [RequestURLQueryID], [ReferrerURLQueryID], [RequestHeadersCollectionID])
VALUES (@exInstanceID, @exWebApplicationID, @AuthenticatedUserName, @HttpVerb, @RequestURLQueryID, @ReferrerURLQueryID, @RequestHeadersCollectionID );",
prms =>
prms.AddInParam("@exInstanceID", SqlDbType.Int, exInstanceID)
// Hosting environment:
.AddInParamSHA1("@exWebApplicationID", exWebApplicationID)
// Request details:
.AddInParamSize("@AuthenticatedUserName", SqlDbType.VarChar, 96, authUserName)
.AddInParamSize("@HttpVerb", SqlDbType.VarChar, 16, http.HttpMethod)
.AddInParamSHA1("@RequestURLQueryID", requestURLQueryID)
.AddInParamSHA1("@ReferrerURLQueryID", referrerURLQueryID)
.AddInParamSHA1("@RequestHeadersCollectionID", exCollectionID)
);
// Log the URLs:
Task tskRequestURL, tskReferrerURL;
tskRequestURL = LogURLQuery(conn, http.Url);
if (http.UrlReferrer != null)
tskReferrerURL = LogURLQuery(conn, http.UrlReferrer);
else
tskReferrerURL = null;
// Await the completion of the tasks:
await Task.WhenAll(tskRequestURL, tskWebApplication, tskContextWeb);
if (tskReferrerURL != null) await tskReferrerURL;
if (tskCollection != null) await tskCollection;
}
async Task<HashedLogIdentifier> LogExceptionRecursively(SqlConnectionContext conn, ExceptionWithCapturedContext ctx, int? parentInstanceID = null)
{
// Create the exTargetSite if it does not exist:
var ts = ctx.TargetSite;
SHA1Hash? exTargetSiteID = null;
Task tskTargetSite = null;
if (ts != null)
{
exTargetSiteID = ts.TargetSiteID;
tskTargetSite = conn.ExecNonQuery(
@"MERGE [dbo].[exTargetSite] WITH (HOLDLOCK) AS target
USING (SELECT @exTargetSiteID) AS source (exTargetSiteID)
ON (target.exTargetSiteID = source.exTargetSiteID)
WHEN NOT MATCHED THEN
INSERT ([exTargetSiteID], [AssemblyName], [TypeName], [MethodName], [ILOffset], [FileName], [FileLineNumber], [FileColumnNumber])
VALUES (@exTargetSiteID, @AssemblyName, @TypeName , @MethodName , @ILOffset , @FileName , @FileLineNumber , @FileColumnNumber );",
prms =>
prms.AddInParamSHA1("@exTargetSiteID", exTargetSiteID.GetValueOrDefault())
.AddInParamSize("@AssemblyName", SqlDbType.NVarChar, 256, ts.AssemblyName)
.AddInParamSize("@TypeName", SqlDbType.NVarChar, 256, ts.TypeName)
.AddInParamSize("@MethodName", SqlDbType.NVarChar, 256, ts.MethodName)
.AddInParam("@ILOffset", SqlDbType.Int, ts.ILOffset)
.AddInParamSize("@FileName", SqlDbType.NVarChar, 256, ts.FileName)
.AddInParam("@FileLineNumber", SqlDbType.Int, ts.FileLineNumber)
.AddInParam("@FileColumnNumber", SqlDbType.Int, ts.FileColumnNumber)
);
}
SHA1Hash? userStateCollectionID = null;
if (ctx.UserState != null)
{
userStateCollectionID = CalcCollectionID(ctx.UserState);
}
// Create the exException record if it does not exist:
var tskGetPolicy = conn.ExecReader(
@"MERGE [dbo].[exException] WITH (HOLDLOCK) AS target
USING (SELECT @exExceptionID) AS source (exExceptionID)
ON (target.exExceptionID = source.exExceptionID)
WHEN NOT MATCHED THEN
INSERT ([exExceptionID], [AssemblyName], [TypeName], [StackTrace], [exTargetSiteID])
VALUES (@exExceptionID, @AssemblyName, @TypeName, @StackTrace, @exTargetSiteID );
SELECT excpol.[LogWebContext], excpol.[LogWebRequestHeaders]
FROM [dbo].[exExceptionPolicy] excpol WITH (NOLOCK)
WHERE excpol.[exExceptionID] = @exExceptionID;",
prms =>
prms.AddInParamSHA1("@exExceptionID", ctx.ExceptionID)
.AddInParamSize("@AssemblyName", SqlDbType.NVarChar, 256, ctx.AssemblyName)
.AddInParamSize("@TypeName", SqlDbType.NVarChar, 256, ctx.TypeName)
.AddInParamSize("@StackTrace", SqlDbType.NVarChar, -1, ctx.StackTrace)
.AddInParamSHA1("@exTargetSiteID", exTargetSiteID),
// Read the SELECT result set into an ExceptionPolicy, or use the default policy:
async dr =>
!await dr.ReadAsync()
? ExceptionPolicy.Default
: new ExceptionPolicy(
logWebContext: dr.GetBoolean(dr.GetOrdinal("LogWebContext")),
logWebRequestHeaders: dr.GetBoolean(dr.GetOrdinal("LogWebRequestHeaders"))
)
);
// Create the exException record if it does not exist:
var exApplicationID = CalcApplicationID(cfg);
var tskApplication = conn.ExecNonQuery(
@"MERGE [dbo].[exApplication] WITH (HOLDLOCK) AS target
USING (SELECT @exApplicationID) AS source (exApplicationID)
ON (target.exApplicationID = source.exApplicationID)
WHEN NOT MATCHED THEN
INSERT ([exApplicationID], [MachineName], [ApplicationName], [EnvironmentName], [ProcessPath])
VALUES (@exApplicationID, @MachineName, @ApplicationName, @EnvironmentName, @ProcessPath );",
prms =>
prms.AddInParamSHA1("@exApplicationID", exApplicationID)
.AddInParamSize("@MachineName", SqlDbType.VarChar, 64, cfg.MachineName)
.AddInParamSize("@ApplicationName", SqlDbType.VarChar, 96, cfg.ApplicationName)
.AddInParamSize("@EnvironmentName", SqlDbType.VarChar, 32, cfg.EnvironmentName)
.AddInParamSize("@ProcessPath", SqlDbType.NVarChar, 256, cfg.ProcessPath)
);
// Create the instance record:
var tskInstance = conn.ExecNonQuery(
@"INSERT INTO [dbo].[exInstance]
([exExceptionID], [exApplicationID], [LoggedTimeUTC], [SequenceNumber], [IsHandled], [ApplicationIdentity], [ParentInstanceID], [CorrelationID], [ManagedThreadId], [UserStateCollectionID], [Message])
VALUES (@exExceptionID, @exApplicationID, @LoggedTimeUTC, @SequenceNumber, @IsHandled, @ApplicationIdentity, @ParentInstanceID, @CorrelationID, @ManagedThreadId, @UserStateCollectionID, @Message );
SET @exInstanceID = SCOPE_IDENTITY();",
prms =>
prms.AddOutParam("@exInstanceID", SqlDbType.Int)
.AddInParamSHA1("@exExceptionID", ctx.ExceptionID)
.AddInParamSHA1("@exApplicationID", exApplicationID)
.AddInParam("@LoggedTimeUTC", SqlDbType.DateTime2, ctx.LoggedTimeUTC)
.AddInParam("@SequenceNumber", SqlDbType.Int, ctx.SequenceNumber)
.AddInParam("@IsHandled", SqlDbType.Bit, ctx.IsHandled)
.AddInParamSize("@ApplicationIdentity", SqlDbType.NVarChar, 128, cfg.ApplicationIdentity)
.AddInParam("@ParentInstanceID", SqlDbType.Int, parentInstanceID)
.AddInParam("@CorrelationID", SqlDbType.UniqueIdentifier, ctx.CorrelationID)
.AddInParam("@ManagedThreadId", SqlDbType.Int, ctx.ManagedThreadID)
.AddInParamSHA1("@UserStateCollectionID", userStateCollectionID)
.AddInParamSize("@Message", SqlDbType.NVarChar, 256, ctx.Exception.Message),
(prms, rc) =>
{
return (int)prms["@exInstanceID"].Value;
}
);
// Await the exInstance record creation:
int exInstanceID = await tskInstance;
// Await the exception policy result:
var policy = await tskGetPolicy;
// If logging the web context is enabled and we have a web context to work with, log it:
Task tskLoggingWeb = null;
if (policy.LogWebContext && ctx.CapturedHttpContext != null)
{
tskLoggingWeb = LogWebContext(conn, policy, ctx, exInstanceID);
}
// Log the UserState collection:
if (userStateCollectionID != null)
await LogCollection(conn, userStateCollectionID.Value, ctx.UserState);
// Wait for any outstanding logging tasks:
if (tskLoggingWeb != null) await tskLoggingWeb;
if (tskTargetSite != null) await tskTargetSite;
await tskApplication;
// Recursively log inner exceptions:
var inner = ctx.InnerException;
if (inner != null)
// Return the inner-most exInstanceID because you can easily drill down through the ParentInstanceID columns to reach the root level.
return await LogExceptionRecursively(conn, inner, exInstanceID);
return new HashedLogIdentifier(ctx.ExceptionID, exInstanceID);
}
/// <summary>
/// Record the exception to the various database tables.
/// </summary>
/// <param name="ctx"></param>
/// <returns></returns>
async Task<ILogIdentifier> WriteDatabase(ExceptionWithCapturedContext ctx, int? parentInstanceID = null)
{
using (var conn = new SqlConnection(cfg.ConnectionString))
{
bool attempt = true;
if (noConnection) attempt = TryReconnect();
if (!attempt) return null;
try
{
// Open connection and check connectivity:
await conn.OpenAsync();
}
catch (Exception inex)
{
// No connectivity; reset attempt timer:
noConnection = true;
lastConnectAttempt = DateTime.UtcNow;
FailoverWrite(new ExceptionWithCapturedContext(inex, isHandled: true));
return null;
}
if (cfg.IsTransactional)
{
// Transactional logging:
using (var tran = conn.BeginTransaction(IsolationLevel.Snapshot))
{
var connCtx = new SqlConnectionContext(conn, tran);
try
{
var logged = await LogExceptionRecursively(connCtx, ctx, null);
tran.Commit();
return logged;
}
catch (Exception ex)
{
tran.Rollback();
FailoverWrite(new ExceptionWithCapturedContext(ex, isHandled: true));
return null;
}
}
}
else
{
// Non-transactional logging:
var connCtx = new SqlConnectionContext(conn);
var logged = await LogExceptionRecursively(connCtx, ctx, null);
return logged;
}
}
}
