/// <summary>
/// Converts the element to a native configuration object it corresponds to -
/// i.e. to a <see cref="SessionConfiguration"/> object.
/// </summary>
/// <returns>The result of conversion.</returns>
public SessionConfiguration ToNative()
{
// Minor hack:
// We should not require user to specify provider name.
// We actually know it when opening new session.
// However, we do not know it in this method
// We are going easy way and substituting a fake provider.
// SQL SessionHandler is aware of this and always uses correct provider.
var connectionInfo = ConnectionInfoParser.GetConnectionInfo(CurrentConfiguration, ConnectionUrl, "_dummy_", ConnectionString);
var result = new SessionConfiguration(Name)
{
UserName = UserName,
Password = Password,
CacheSize = CacheSize,
BatchSize = BatchSize,
CacheType = (SessionCacheType)Enum.Parse(typeof(SessionCacheType), CacheType, true),
Options = (SessionOptions)Enum.Parse(typeof(SessionOptions), Options, true),
DefaultIsolationLevel = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), DefaultIsolationLevel, true),
ReaderPreloading = (ReaderPreloadingPolicy)Enum.Parse(typeof(ReaderPreloadingPolicy), ReaderPreloading, true),
ServiceContainerType = Type.GetType(ServiceContainerType),
EntityChangeRegistrySize = EntityChangeRegistrySize,
DefaultCommandTimeout = DefaultCommandTimeout,
ConnectionInfo = connectionInfo,
};
return(result);
}
/// <summary>
/// Converts the element to a native configuration object it corresponds to -
/// i.e. to a <see cref="DomainConfiguration"/> object.
/// </summary>
/// <returns>The result of conversion.</returns>
public DomainConfiguration ToNative()
{
var config = new DomainConfiguration {
Name = Name,
ConnectionInfo = ConnectionInfoParser.GetConnectionInfo(CurrentConfiguration, ConnectionUrl, Provider, ConnectionString),
NamingConvention = NamingConvention.ToNative(),
KeyCacheSize = KeyCacheSize,
KeyGeneratorCacheSize = KeyGeneratorCacheSize,
QueryCacheSize = QueryCacheSize,
RecordSetMappingCacheSize = RecordSetMappingCacheSize,
DefaultSchema = DefaultSchema,
DefaultDatabase = DefaultDatabase,
UpgradeMode = ParseEnum <DomainUpgradeMode>(UpgradeMode),
ForeignKeyMode = ParseEnum <ForeignKeyMode>(ForeignKeyMode),
SchemaSyncExceptionFormat = ParseEnum <SchemaSyncExceptionFormat>(SchemaSyncExceptionFormat),
Options = ParseEnum <DomainOptions>(Options),
ServiceContainerType = ServiceContainerType.IsNullOrEmpty() ? null : Type.GetType(ServiceContainerType),
IncludeSqlInExceptions = IncludeSqlInExceptions,
BuildInParallel = BuildInParallel,
AllowCyclicDatabaseDependencies = AllowCyclicDatabaseDependencies,
ForcedServerVersion = ForcedServerVersion,
Collation = Collation,
ConnectionInitializationSql = ConnectionInitializationSql,
MultidatabaseKeys = MultidatabaseKeys,
ShareStorageSchemaOverNodes = ShareStorageSchemaOverNodes,
EnsureConnectionIsAlive = EnsureConnectionIsAlive,
FullTextChangeTrackingMode = ParseEnum <FullTextChangeTrackingMode>(FullTextChangeTrackingMode),
VersioningConvention = VersioningConvention.ToNative()
};
foreach (var element in Types)
{
config.Types.Register(element.ToNative());
}
foreach (var element in Sessions)
{
config.Sessions.Add(element.ToNative());
}
foreach (var element in MappingRules)
{
config.MappingRules.Add(element.ToNative());
}
foreach (var element in Databases)
{
config.Databases.Add(element.ToNative());
}
foreach (var element in KeyGenerators)
{
config.KeyGenerators.Add(element.ToNative());
}
foreach (var element in IgnoreRules)
{
config.IgnoreRules.Add(element.ToNative());
}
return(config);
}
public void ConnectionStringParser_DifferentConnectionStrings_NotMatched()
{
var connectionString1 = @"Server=win-database.pdx.vm.datanerd.us\SQLEXPRESS;Database=NewRelic;";
var connectionString2 = @"Server=win-database.pdx.vm.datanerd.us,1433\SQLEXPRESS;Database=NewRelic;";
var connectionInfo1 = ConnectionInfoParser.FromConnectionString(DatastoreVendor.MSSQL, connectionString1);
var connectionInfo2 = ConnectionInfoParser.FromConnectionString(DatastoreVendor.MSSQL, connectionString2);
Assert.AreNotSame(connectionInfo1, connectionInfo2);
}
public void TestConnectionStringParsing(DatastoreVendor vendor, string expectedHost, string expectedPathPortOrId, string expectedDatabaseName, string expectedInstanceName, string connectionString)
{
if (expectedHost == "hostname_of_localhost")
{
expectedHost = Dns.GetHostName();
}
var connectionInfo = ConnectionInfoParser.FromConnectionString(vendor, connectionString);
Assert.True(connectionInfo.Host == expectedHost);
Assert.True(connectionInfo.PortPathOrId == expectedPathPortOrId);
Assert.True(connectionInfo.DatabaseName == expectedDatabaseName);
Assert.True(connectionInfo.InstanceName == expectedInstanceName);
}
public AfterWrappedMethodDelegate BeforeWrappedMethod(InstrumentedMethodCall instrumentedMethodCall, IAgent agent, ITransaction transaction)
{
//This only happens if we are in an async context. Regardless if we are adding the after delegate as a contination.
if (instrumentedMethodCall.IsAsync)
{
transaction.AttachToAsync();
}
var sqlCommand = (IDbCommand)instrumentedMethodCall.MethodCall.InvocationTarget;
if (sqlCommand == null)
{
return(Delegates.NoOp);
}
var sql = sqlCommand.CommandText ?? string.Empty;
var vendor = SqlWrapperHelper.GetVendorName(sqlCommand);
object GetConnectionInfo() => ConnectionInfoParser.FromConnectionString(vendor, sqlCommand.Connection.ConnectionString);
var connectionInfo = (ConnectionInfo)transaction.GetOrSetValueFromCache(sqlCommand.Connection.ConnectionString, GetConnectionInfo);
var parsedStatement = transaction.GetParsedDatabaseStatement(vendor, sqlCommand.CommandType, sql);
var queryParameters = SqlWrapperHelper.GetQueryParameters(sqlCommand, agent);
var segment = transaction.StartDatastoreSegment(instrumentedMethodCall.MethodCall, parsedStatement, connectionInfo, sql, queryParameters, isLeaf: true);
switch (vendor)
{
case DatastoreVendor.MSSQL:
agent.EnableExplainPlans(segment, () => SqlServerExplainPlanActions.AllocateResources(sqlCommand), SqlServerExplainPlanActions.GenerateExplainPlan, null);
break;
case DatastoreVendor.MySQL:
if (parsedStatement != null)
{
agent.EnableExplainPlans(segment, () => MySqlExplainPlanActions.AllocateResources(sqlCommand), MySqlExplainPlanActions.GenerateExplainPlan, () => MySqlExplainPlanActions.ShouldGenerateExplainPlan(sql, parsedStatement));
}
break;
}
return(ExecuteAsAsync
? Delegates.GetAsyncDelegateFor <Task>(agent, segment)
: Delegates.GetDelegateFor(segment));
}
