/// <summary> /// Creates a ProfiledDbConnection instance and opens it /// </summary> public static DbConnection New(IDbConnectionFactory connectionFactory, IDbProfiler dbProfiler) { var connection = new ProfiledDbConnection(connectionFactory.CreateConnection(), dbProfiler); connection.Open(); return(connection); }
/// <summary> /// Creates a database connection based on the specified database information object. /// </summary> internal DBConnection(DatabaseInfo databaseInfo /*, int? timeout */) { this.databaseInfo = databaseInfo; // NOTE SJR: We're going to have to generate code to retrieve this value. this.timeout = timeout; cn = new ProfiledDbConnection(databaseInfo.CreateConnection(), MiniProfiler.Current); }
protected IDbConnection GetConnection() { SqlConnection sqlConnection = new SqlConnection(_connectionString); var wrapperConnection = new ProfiledDbConnection(sqlConnection, MiniProfiler.Current); return(wrapperConnection); }
public static DbConnection GetConnection() { var conn = new SqlConnection(@"Server=(LocalDb)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\SimpleDemoDB.mdf;Database=SimpleDemoDB;Trusted_Connection=Yes;"); // wrap the connection with ProfiledDbConnection that tracks timings var dbProfiler = new ProfiledDbConnection(conn, new DbProfiler(ProfilingSession.Current.Profiler)); return(dbProfiler); }
/// <summary> /// The EF code first. /// </summary> /// <returns>the entity framework code first view.</returns> public ActionResult EFCodeFirst() { int count; int?newCount = null; EFContext context = null; using (MiniProfiler.Current.Step("EF Stuff")) { try { using (MiniProfiler.Current.Step("Create Context")) context = new EFContext(); // this is not correct, as the count from this assignment is never actually used using (MiniProfiler.Current.Step("First count")) count = context.People.Count(); using (MiniProfiler.Current.Step("Insertion")) { var p = new Person { Name = "sam" }; context.People.Add(p); context.SaveChanges(); } // this count is actually used. using (MiniProfiler.Current.Step("Second count")) count = context.People.Count(); const string sql = "Select count(*) from People"; using (MiniProfiler.Current.Step("Get Count from SqlQuery Method - no sql recorded")) { newCount = context.Database.SqlQuery <int>(sql).Single(); } using (MiniProfiler.Current.Step("Get Count using ProfiledConnection - sql recorded")) { using (var conn = new ProfiledDbConnection(context.Database.Connection, MiniProfiler.Current)) { conn.Open(); newCount = conn.Query <int>(sql).Single(); conn.Close(); } } } finally { if (context != null) { context.Dispose(); } } } return(Content(string.Format("EF Code First complete - count: {0}, sqlQuery count {1}", count, newCount))); }
public IDbConnection GetConnection(string connectionString) { var conn = new ProfiledDbConnection( new SqlConnection(connectionString), () => ProfilingSession.Current == null ? null : new DbProfiler(ProfilingSession.Current.Profiler) ); return(conn); }
public static DbConnection GetConnection(MiniProfiler profiler) { var connection = new SQLiteConnection("Data Source=:memory:"); // to get profiling times, we have to wrap whatever connection we're using in a ProfiledDbConnection // when profiler is null, this connection will not record any database timings var profiled = new ProfiledDbConnection(connection, profiler); profiled.Open(); return(profiled); }
public static IServiceCollection AddDapper(this IServiceCollection services, string connectionString) { services.AddScoped <IDbConnection>((sp) => { //采用MiniProfiler 用于性能分析 var client = new ProfiledDbConnection(new SqlConnection(connectionString), MiniProfiler.Current); client.Open(); return(client); }); return(services); }
public void TestProfiledStoredProcWithParameters() { using (var connection = ConnectionWithTransaction()) { connection.ExecuteSql("CREATE PROC InsightTestProcMiniProfiler (@Value int = 5) AS SELECT Value=@Value"); var profiled = new ProfiledDbConnection((DbConnection)connection, MiniProfiler.Current); var result = profiled.Query <int>("InsightTestProcMiniProfiler", new { Value = 1 }).First(); Assert.AreEqual((int)1, result); } }
private async Task <DbConnection> OpenConnection(DbProviderFactory factory = null) { factory = factory ?? m_factory; var connection = new ProfiledDbConnection(factory.CreateConnection(), MiniProfiler.Current); connection.ConnectionString = m_connectionString; await connection.OpenAsync(); return(connection); }
public override DbConnection CreateConnection() { var sqliteConnection = new SqlCeConnection(); DbConnection connection = sqliteConnection; if (IsProfiled) { connection = new ProfiledDbConnection(sqliteConnection, MiniProfiler.Current); } return(connection); }
/// <summary> /// Gets an open READ UNCOMMITTED connection using the specified connection string, optionally timing out on the initial connect. /// </summary> /// <param name="connectionString">The connection string to use for the connection.</param> /// <param name="connectionTimeoutMs">(Optional) Milliseconds to wait to connect.</param> /// <returns>A READ UNCOMMITTED connection to the specified connection string.</returns> /// <exception cref="Exception">Throws if a connection isn't able to be made.</exception> /// <exception cref="TimeoutException">Throws if a connection can't be made in <paramref name="connectionTimeoutMs"/>.</exception> public static async Task <DbConnection> GetOpenAsync(string connectionString, int?connectionTimeoutMs = null) { var conn = new ProfiledDbConnection(new SqlConnection(connectionString), MiniProfiler.Current); var tmpTimeout = connectionTimeoutMs.GetValueOrDefault(0); if (connectionTimeoutMs.GetValueOrDefault(0) == 0) { await conn.OpenAsync().ConfigureAwait(false); await conn.SetReadUncommittedAsync().ConfigureAwait(false); } else { // In the case of remote monitoring, the timeout will be at the NIC level, not responding to traffic, // in that scenario, connection timeouts don't really do much, because they're never reached, the timeout happens // before their timer starts. Because of that, we need to spin up our own overall timeout using (MiniProfiler.Current.Step($"Opening Connection, Timeout: {conn.ConnectionTimeout}")) using (var tokenSource = new CancellationTokenSource()) { tokenSource.CancelAfter(connectionTimeoutMs.Value); try { await conn.OpenAsync(tokenSource.Token).ConfigureAwait(false); // Throwing Null Refs await conn.SetReadUncommittedAsync().ConfigureAwait(false); } catch (TaskCanceledException e) { conn.Close(); var csb = new SqlConnectionStringBuilder(connectionString); var sqlException = $"Error opening connection to {csb.InitialCatalog} at {csb.DataSource}, timeout out at {connectionTimeoutMs.ToComma()} ms"; throw new Exception(sqlException, e); } catch (SqlException e) { conn.Close(); var csb = new SqlConnectionStringBuilder(connectionString); var sqlException = $"Error opening connection to {csb.InitialCatalog} at {csb.DataSource}: {e.Message}"; throw new Exception(sqlException, e); } if (conn.State == ConnectionState.Connecting) { tokenSource.Cancel(); var b = new SqlConnectionStringBuilder { ConnectionString = connectionString }; throw new TimeoutException($"Timeout expired connecting to {b.InitialCatalog} on {b.DataSource} on in the alloted {connectionTimeoutMs.Value.ToComma()} ms"); } } } return(conn); }
/// <summary> /// Creates a database connection based on the specified database information object. /// </summary> internal DBConnection(DatabaseInfo databaseInfo) { this.databaseInfo = databaseInfo; // Build the connection string. string connectionString; if (databaseInfo is SqlServerInfo) { var sqlServerInfo = databaseInfo as SqlServerInfo; connectionString = "Data Source=" + (sqlServerInfo.Server ?? "(local)"); if (sqlServerInfo.LoginName != null) { connectionString += "; User ID=" + sqlServerInfo.LoginName; connectionString += "; Password='******'".FormatWith(sqlServerInfo.Password); } else { connectionString += "; Integrated Security=SSPI"; } connectionString += "; Initial Catalog=" + sqlServerInfo.Database; if (!sqlServerInfo.SupportsConnectionPooling) { connectionString += "; Pooling=false"; } } else if (databaseInfo is MySqlInfo) { var mySqlInfo = databaseInfo as MySqlInfo; connectionString = "Host=localhost; User Id=root; Password=password; Initial Catalog=" + mySqlInfo.Database; if (!mySqlInfo.SupportsConnectionPooling) { connectionString += "; Pooling=false"; } } else if (databaseInfo is OracleInfo) { var oracleInfo = databaseInfo as OracleInfo; connectionString = "Data Source=" + oracleInfo.DataSource + "; User Id=" + oracleInfo.UserAndSchema + "; Password="******"sys" ? "; DBA Privilege=SYSDBA" : ""); if (!oracleInfo.SupportsConnectionPooling) { connectionString = StringTools.ConcatenateWithDelimiter("; ", connectionString, "Pooling=false"); } } else { throw new ApplicationException("Invalid database information object type."); } cn = new ProfiledDbConnection(databaseInfo.CreateConnection(connectionString), MiniProfiler.Current); }
/// <summary> /// To Open a new connection. /// </summary> /// <param name="objSqlConn">Sql connection object</param> /// <returns>if the connection establish successfully then return true else false</returns> public void OpenConnection(ref DbConnection objSqlConn) { try { objSqlConn = new ProfiledDbConnection(new SqlConnection(connString), MiniProfiler.Current); if (objSqlConn.State == ConnectionState.Closed) { objSqlConn.Open(); } } catch { } }
/// <summary> /// Gets an open READ UNCOMMITTED connection using the specified connection string, optionally timing out on the initial connect. /// </summary> /// <param name="connectionString">The connection string to use for the connection.</param> /// <param name="connectionTimeoutMs">(Optional) Milliseconds to wait to connect.</param> /// <returns>A READ UNCOMMITTED connection to the specified connection string.</returns> /// <exception cref="Exception">Throws if a connection isn't able to be made.</exception> /// <exception cref="TimeoutException">Throws if a connection can't be made in <paramref name="connectionTimeoutMs"/>.</exception> public static DbConnection GetOpen(string connectionString, int?connectionTimeoutMs = null) { var conn = new ProfiledDbConnection(new SqlConnection(connectionString), MiniProfiler.Current); void setReadUncommitted(DbConnection c) { using (var cmd = c.CreateCommand()) { cmd.CommandText = "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"; cmd.ExecuteNonQueryAsync(); } } if (connectionTimeoutMs.GetValueOrDefault(0) == 0) { conn.OpenAsync(); setReadUncommitted(conn); } else { // In the case of remote monitoring, the timeout will be at the NIC level, not responding to traffic, // in that scenario, connection timeouts don't really do much, because they're never reached, the timeout happens // before their timer starts. Because of that, we need to spin up our own overall timeout using (MiniProfiler.Current.Step($"Opening Connection, Timeout: {conn.ConnectionTimeout}")) { try { conn.Open(); } catch (SqlException e) { var csb = new SqlConnectionStringBuilder(connectionString); var sqlException = $"Error opening connection to {csb.InitialCatalog} at {csb.DataSource} timeout was: {connectionTimeoutMs.ToComma()} ms"; throw new Exception(sqlException, e) .AddLoggedData("Timeout", conn.ConnectionTimeout.ToString()); } } setReadUncommitted(conn); if (conn.State == ConnectionState.Connecting) { var b = new SqlConnectionStringBuilder { ConnectionString = connectionString }; throw new TimeoutException($"Timeout expired connecting to {b.InitialCatalog} on {b.DataSource} on in the alloted {connectionTimeoutMs.ToComma()} ms"); } } return(conn); }
public async Task <IList <string> > Test(int delay, CancellationToken cancellationToken) { var result = new List <string>(); using (this.profiler.Profile(new ProfileOperationSpecification("test"))) { using (var connection = new ProfiledDbConnection(new SqlConnection(ConfigurationManager.ConnectionStrings["Test"].ConnectionString))) { { var id = (await connection.QueryAsync <int>( "select top 1 Id from TestRocksProfilingTable where 1 = 1 order by Id desc; " + $"waitfor delay '{TimeSpan.FromMilliseconds(delay)}';")).FirstOrNull(); result.Add($"Selected via ADO+Dapper: {id}"); } using (var command = connection.CreateCommand()) { if (connection.State != ConnectionState.Open) { await connection.OpenAsync(cancellationToken); } command.CommandText = "select top 1 Id from TestRocksProfilingTable where 2 = 2 order by Id desc; " + $"waitfor delay '{TimeSpan.FromMilliseconds(delay)}';"; var id = await command.ExecuteScalarAsync(cancellationToken) as int?; result.Add($"Selected via ADO: {id}"); } using (var command = connection.CreateCommand()) { if (connection.State != ConnectionState.Open) { await connection.OpenAsync(cancellationToken); } command.CommandText = "select top 1 Id from TestRocksProfilingTable where 3 = 3 order by Id desc; " + $"waitfor delay '{TimeSpan.FromMilliseconds(delay)}';"; var id = await command.ExecuteScalarAsync(cancellationToken) as int?; result.Add($"Selected via ADO (2): {id}"); } } return(result); } }
/// <summary> /// Returns an open connection that will have its queries profiled. /// </summary> public static DbConnection GetSqliteConnection() { DbConnection cnn = new System.Data.SQLite.SQLiteConnection("Data Source=:memory:"); // to get profiling times, we have to wrap whatever connection we're using in a ProfiledDbConnection // when MiniProfiler.Current is null, this connection will not record any database timings if (MiniProfiler.Current != null) { cnn = new ProfiledDbConnection(cnn, MiniProfiler.Current); } cnn.Open(); return(cnn); }
public UnitOfWork(IConfiguration configuration) { var connStr = configuration.GetConnectionString("MySqlConnection"); //if (!string.IsNullOrEmpty("MySQL Data Provider")) // _providerName = "MySQL Data Provider"; //else // throw new Exception("ConnectionStrings中没有配置提供程序ProviderName!"); //_dbFactory = DbProviderFactories.GetFactory(_providerName); //_connection = _dbFactory.CreateConnection(); //_connection.ConnectionString = connStr; _connection = new ProfiledDbConnection(new MySqlConnection(connStr), MiniProfiler.Current); _connection.Open(); SetParamPrefix(); }
public void GetDbConnectionType_ByDelegate() { FeatureSupportWrapper.GetDbConnectionType = (conn) => { if (conn is ProfiledDbConnection) { return(((ProfiledDbConnection)conn).WrappedConnection.GetType()); } return(conn?.GetType()); }; using (var conn = new ProfiledDbConnection(new NpgsqlConnection(), MiniProfiler.Current)) { Assert.Equal("npgsqlconnection", FeatureSupportWrapper.GetDbConnectionType(conn).Name.ToLower()); } }
private void DestroyDbConnection(IDbConnection connection) { ProfiledDbConnection profiled = connection as ProfiledDbConnection; if (profiled != null) // for some reason, MiniProfiler profiled Db Connections are disposed at some point. { if (profiled.WrappedConnection != null) { profiled.WrappedConnection.Close(); } } else { connection.Close(); } }
public DbConnection GetConnection(MiniProfiler profiler = null) { using (profiler.Step(nameof(GetConnection))) { DbConnection cnn = new System.Data.SqlClient.SqlConnection("Server=(localdb)\\mssqllocaldb;Database=IMDBChallenge;Trusted_Connection=True;MultipleActiveResultSets=true"); // to get profiling times, we have to wrap whatever connection we're using in a ProfiledDbConnection // when MiniProfiler.Current is null, this connection will not record any database timings if (MiniProfiler.Current != null) { cnn = new ProfiledDbConnection(cnn, MiniProfiler.Current); } cnn.Open(); return(cnn); } }
public async Task <LabExecution> GetLabExecutionForUserAsync(int userId, int labId, CancellationToken cancellationToken) { // We have to match against user IDs, which does not seem to be supported by EF var dbConn = new ProfiledDbConnection(_dbContext.Database.GetDbConnection(), MiniProfiler.Current); var labExecutionEntity = (await dbConn.QueryAsync <LabExecutionEntity>(@" SELECT le.* FROM `LabExecutions` le INNER JOIN `Groups` g ON g.`Id` = le.`GroupId` WHERE le.`LabId` = @labId AND g.`Id` = ( SELECT u.`GroupId` FROM `Users` u WHERE u.`Id` = @userId )", new { labId, userId })).FirstOrDefault(); return(_mapper.Map <LabExecutionEntity, LabExecution>(labExecutionEntity)); }
/// <summary> /// Returns an open connection that will have its queries profiled. /// </summary> /// <param name="profiler">The mini profiler.</param> /// <returns>the data connection abstraction.</returns> public DbConnection GetConnection(MiniProfiler profiler = null) { using (profiler.Step("GetOpenConnection")) { DbConnection cnn = new SqliteConnection(Startup.SqliteConnectionString); // to get profiling times, we have to wrap whatever connection we're using in a ProfiledDbConnection // when MiniProfiler.Current is null, this connection will not record any database timings if (MiniProfiler.Current != null) { cnn = new ProfiledDbConnection(cnn, MiniProfiler.Current); } cnn.Open(); return(cnn); } }
/// <summary> /// Gets an open READ UNCOMMITTED connection using the specified connection string, optionally timing out on the initial connect /// </summary> /// <param name="connectionString">The connection string to use for the connection</param> /// <param name="connectionTimeout">Milliseconds to wait to connect, optional</param> /// <returns>A READ UNCOMMITTED connection to the specified connection string</returns> public static async Task <DbConnection> GetOpenAsync(string connectionString, int?connectionTimeout = null) { var conn = new ProfiledDbConnection(new SqlConnection(connectionString), MiniProfiler.Current); if (connectionTimeout.GetValueOrDefault(0) == 0) { await conn.OpenAsync(); await SetReadUncommitted(conn); } else { // In the case of remote monitoring, the timeout will be at the NIC level, not responding to traffic, // in that scenario, connection timeouts don't really do much, because they're never reached, the timeout happens // before their timer starts. Because of that, we need to spin up our own overall timeout using (MiniProfiler.Current.Step("Opening Connection, Timeout: " + conn.ConnectionTimeout)) using (var tokenSource = new CancellationTokenSource()) { tokenSource.CancelAfter(connectionTimeout.Value); try { await conn.OpenAsync(tokenSource.Token); // Throwing Null Refs } catch (SqlException e) { var csb = new SqlConnectionStringBuilder(connectionString); var sqlException = string.Format("Error opening connection to {0} at {1} timeout was: {2} ms", csb.InitialCatalog, csb.DataSource, connectionTimeout.ToComma()); throw new Exception(sqlException, e); } await SetReadUncommitted(conn); if (conn.State == ConnectionState.Connecting) { tokenSource.Cancel(); var b = new SqlConnectionStringBuilder { ConnectionString = connectionString }; throw new TimeoutException("Timeout expired connecting to " + b.InitialCatalog + " on " + b.DataSource + " on in the alloted " + connectionTimeout.Value.ToComma() + " ms"); } } } return(conn); }
/// <summary> /// Asynchronously returns an open connection that will have its queries profiled. /// </summary> /// <param name="profiler">The mini profiler.</param> /// <returns>the data connection abstraction.</returns> public async Task <DbConnection> GetConnectionAsync(MiniProfiler profiler = null) { using (profiler.Step("GetOpenConnectionAsync")) { DbConnection cnn = new SqliteConnection(Startup.SqliteConnectionString); // to get profiling times, we have to wrap whatever connection we're using in a ProfiledDbConnection // when MiniProfiler.Current is null, this connection will not record any database timings if (MiniProfiler.Current != null) { cnn = new ProfiledDbConnection(cnn, MiniProfiler.Current); } await cnn.OpenAsync().ConfigureAwait(false); return(cnn); } }
public static async Task <DbDataReader> ExecuteReaderAsync( this MySqlConnection conn, string spName, IEnumerable <MySqlParameter> parameters, MySqlTransaction transaction) { using (var cmd = new ProfiledDbConnection(conn).CreateCommand()) { cmd.CommandText = spName; cmd.CommandType = CommandType.StoredProcedure; cmd.Transaction = transaction; if (parameters != null) { cmd.Parameters.AddRange(parameters.ToArray()); } return(await cmd.ExecuteReaderAsync()); } }
/// <summary> /// The EF core. /// </summary> /// <returns>The entity framework core.</returns> public ActionResult EFCore() { int count; int?newCount = null; EFContext context = null; //using (var connection = new ProfiledDbConnection(new SqliteConnection("DataSource=:memory:"), MiniProfiler.Current)) // dotnet\sdk\NuGetFallbackFolder\microsoft.data.sqlite.core\2.0.0\lib\netstandard2.0\Microsoft.Data.Sqlite.dll using (var connection = new SqliteConnection("DataSource=:memory:")) using (MiniProfiler.Current.Step("EF Core Stuff")) { try { connection.Open(); var options = new DbContextOptionsBuilder <EFContext>() .UseSqlite(connection) .Options; using (MiniProfiler.Current.Step("Create Context")) { context = new EFContext(options); } using (MiniProfiler.Current.Step("Create Schema")) { context.Database.EnsureCreated(); } // this is not correct, as the count from this assignment is never actually used using (MiniProfiler.Current.Step("First count")) { count = context.People.Count(); } using (MiniProfiler.Current.Step("Insertion")) { var p = new Person { Name = "sam" }; context.People.Add(p); context.SaveChanges(); } // this count is actually used. using (MiniProfiler.Current.Step("Second count")) { count = context.People.Count(); } using (MiniProfiler.Current.Step("Get Count from SqlQuery Method - no sql recorded")) { newCount = context.People.FromSql("Select * from People").Count(); } using (MiniProfiler.Current.Step("Get Count using ProfiledConnection - sql recorded")) { using (var conn = new ProfiledDbConnection(context.Database.GetDbConnection(), MiniProfiler.Current)) { conn.Open(); newCount = conn.Query <int>("Select Count(*) from People").Single(); conn.Close(); } } } finally { context?.Dispose(); } } return(Content(string.Format("EF Code First complete - count: {0}, sqlQuery count {1}", count, newCount))); }
public static IContainer RegisterDependencies(IServiceCollection services, IHostingEnvironment env, IConfiguration rootConfiguration) { var assemblies = AppDomain.CurrentDomain.GetAssemblies(); var builder = new ContainerBuilder(); builder.Populate(services); RegisterCredentials(builder); if (env.IsDevelopment()) { OverrideWithLocalCredentials(builder); } builder.Register <IDiscoveryCache>(b => { var configuration = b.Resolve <IConfiguration>(); var cache = new DiscoveryCache(configuration["Auth:Client:Url"]); return(cache); }).SingleInstance(); builder.Register(b => { return(rootConfiguration); }).SingleInstance(); builder.Register(b => { var redis = b.Resolve <ConnectionMultiplexer>(); return(redis.GetDatabase()); }).InstancePerLifetimeScope(); builder.Register(b => { var configuration = b.Resolve <IConfiguration>(); var redis = b.Resolve <ConnectionMultiplexer>(); return(redis.GetServer(configuration["Redis:Url"])); }).InstancePerLifetimeScope(); builder.RegisterType <IEventDispatcher>().AsImplementedInterfaces().InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(IEventHandler <>)).InstancePerDependency(); builder.RegisterType <CommandDispatcher>().As <ICommandDispatcher>().InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(ICommandHandler <>)).InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(ICommandHandler <,>)).InstancePerLifetimeScope(); builder.RegisterType <QueryDispatcher>().As <IQueryDispatcher>().InstancePerRequest().InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(IQueryHandler <,>)).InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(AppAbstractValidation <>)).InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(IReadCacheHandler <,>)).InstancePerLifetimeScope(); builder.RegisterAssemblyTypes(assemblies).AsClosedTypesOf(typeof(IWriteCacheHandler <,>)).InstancePerLifetimeScope(); builder.Register <ILogger>(b => { var format = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {NewLine}{Message:lj}{NewLine}{Exception}"; return(new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Console(outputTemplate: format) .WriteTo.File("Logs/log.txt", rollingInterval: RollingInterval.Day, restrictedToMinimumLevel: LogEventLevel.Error, outputTemplate: format) .WriteTo.Logger(cl => cl.Filter.ByIncludingOnly(evt => evt.Level == LogEventLevel.Information).WriteTo.File("Logs/queries.txt", rollingInterval: RollingInterval.Day, restrictedToMinimumLevel: LogEventLevel.Information, outputTemplate: format)) .CreateLogger()); }); builder.Register <IClock>(b => { return(SystemClock.Instance); }).SingleInstance(); builder.Register <IMemoryCache>(b => { return(new MemoryCache(new MemoryCacheOptions())); }).SingleInstance(); builder.RegisterType <ProfileDbConnection>().AsImplementedInterfaces().SingleInstance(); builder.Register <IDatabaseConnector <JobDatabaseCredentials> >(b => { var databaseCredentials = b.Resolve <JobDatabaseCredentials>(); var profiler = b.Resolve <IDbProfiler>(); ProfiledDbConnection databaseConnection = new ProfiledDbConnection(new SqlConnection(databaseCredentials.ConnectionString), profiler); return(new DapperConnector <JobDatabaseCredentials>(databaseConnection)); }).InstancePerLifetimeScope(); builder.RegisterType <GuidService>().AsImplementedInterfaces().InstancePerLifetimeScope(); builder.RegisterType <CurrentUserProvider>().AsImplementedInterfaces().InstancePerLifetimeScope(); builder.RegisterType <RandomService>().AsImplementedInterfaces().SingleInstance(); builder.RegisterType <EventHubService>().AsImplementedInterfaces().SingleInstance(); builder.Register <IClock>(b => { return(SystemClock.Instance); }).SingleInstance(); builder.Register(b => { var connectionStringBuilder = b.Resolve <EventHubsConnectionStringBuilder>(); return(EventHubClient.CreateFromConnectionString(connectionStringBuilder.ToString())); }).InstancePerLifetimeScope(); return(builder.Build()); }
/// <summary> /// Unwraps the given connection and returns the inner connection. /// </summary> /// <param name="connection">The outer connection.</param> /// <returns>The inner connection.</returns> public override IDbConnection GetInnerConnection(IDbConnection connection) { ProfiledDbConnection profiledConnection = (ProfiledDbConnection)connection; return(profiledConnection.InnerConnection); }
public ProfiledTransactionWrapper(DbTransaction transaction, ProfiledDbConnection connection) : base(transaction, connection) { Transaction = transaction; }