public PerformanceTelemetryPayloadFactory(
IErrorContextFactory errorContextFactory,
ITelemetryLogger logger,
IThreadIdProvider threadIdProvider,
IPerformanceContainer container)
{
if (errorContextFactory == null)
{
throw new ArgumentNullException("errorContextFactory");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (threadIdProvider == null)
{
throw new ArgumentNullException("threadIdProvider");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
_errorContextFactory = errorContextFactory;
_logger = logger;
_threadIdProvider = threadIdProvider;
_container = container;
}
public MultipleXmlItemSaverFactory(
ITelemetryLogger logger,
IXmlPreparator xmlPreparator,
params IXmlSaver[] savers
)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (xmlPreparator == null)
{
throw new ArgumentNullException("xmlPreparator");
}
if (savers == null)
{
throw new ArgumentNullException("savers");
}
if (savers.Length == 0)
{
throw new ArgumentException("savers");
}
if (savers.Any(j => j == null))
{
throw new ArgumentException("savers.Any(j => j == null)");
}
_logger = logger;
_xmlPreparator = xmlPreparator;
_savers = savers;
}
public PerformanceTelemetryPayload(
IErrorContext errorContext,
ITelemetryLogger logger,
IThreadIdProvider threadIdProvider,
IPerformanceContainer container,
string className,
string methodName)
{
if (errorContext == null)
{
throw new ArgumentNullException("errorContext");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (threadIdProvider == null)
{
throw new ArgumentNullException("threadIdProvider");
}
if (container == null)
{
throw new ArgumentNullException("container");
}
if (className == null)
{
throw new ArgumentNullException("className");
}
if (methodName == null)
{
throw new ArgumentNullException("methodName");
}
this._errorContext = errorContext;
this._logger = logger;
this._container = container;
this._manageThreadId = threadIdProvider.GetCurrentThreadId();
this._record = _container.OpenPerformanceSession(
this._manageThreadId,
className,
methodName);
}
public EventBasedSaver(
IItemSaverFactory itemSaverFactory,
ITelemetryLogger logger,
bool suppressExceptions = true
)
{
if (itemSaverFactory == null)
{
throw new ArgumentNullException("itemSaverFactory");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_itemSaverFactory = itemSaverFactory;
_logger = logger;
_suppressExceptions = suppressExceptions;
}
public MigrationEngine(
IServiceProvider services,
ExecuteOptions executeOptions,
EngineConfiguration config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
FieldMapContainer fieldMaps,
ITelemetryLogger telemetry)
{
Log.Information("Creating Migration Engine {SessionId}", telemetry.SessionId);
_services = services;
FieldMaps = fieldMaps;
this.executeOptions = executeOptions;
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
Config = config;
}
/// Records Telemetry Event:
/// Sample event that uses types from this definition only
public static void RecordSampleReleaseBees(this ITelemetryLogger telemetryLogger, SampleReleaseBees payload)
{
try
{
var metrics = new Metrics();
if (payload.CreatedOn.HasValue)
{
metrics.CreatedOn = payload.CreatedOn.Value;
}
else
{
metrics.CreatedOn = System.DateTime.Now;
}
metrics.Data = new List <MetricDatum>();
var datum = new MetricDatum();
datum.MetricName = "sample_releaseBees";
datum.Unit = Unit.None;
datum.Passive = false;
if (payload.Value.HasValue)
{
datum.Value = payload.Value.Value;
}
else
{
datum.Value = 1;
}
datum.AddMetadata("bees", payload.Bees);
metrics.Data.Add(datum);
telemetryLogger.Record(metrics);
}
catch (System.Exception e)
{
telemetryLogger.Logger.Error("Error recording telemetry event", e);
System.Diagnostics.Debug.Assert(false, "Error Recording Telemetry");
}
}
protected static ILogger BuildLogger(ITelemetryLogger telemetryLogger)
{
var builder = new ConfigurationBuilder();
BuildAppConfig(builder);
string logsPath = CreateLogsPath();
var logPath = Path.Combine(logsPath, "migration.log");
var logconf = new LoggerConfiguration()
.ReadFrom.Configuration(builder.Build())
.Enrich.FromLogContext()
.Enrich.WithMachineName()
.Enrich.WithProcessId()
.WriteTo.Console()
.WriteTo.ApplicationInsights(telemetryLogger.Configuration, new CustomConverter())
.WriteTo.File(logPath)
.CreateLogger();
Log.Information("Writing log to {logPath}", logPath);
return(logconf);
}
/// Records Telemetry Event:
/// Sample event that uses a unit
public static void RecordSampleTestRun(this ITelemetryLogger telemetryLogger, SampleTestRun payload)
{
try
{
var metrics = new Metrics();
if (payload.CreatedOn.HasValue)
{
metrics.CreatedOn = payload.CreatedOn.Value;
}
else
{
metrics.CreatedOn = System.DateTime.Now;
}
metrics.Data = new List <MetricDatum>();
var datum = new MetricDatum();
datum.MetricName = "sample_testRun";
datum.Unit = Unit.Milliseconds;
datum.Passive = payload.Passive;
if (payload.Value.HasValue)
{
datum.Value = payload.Value.Value;
}
else
{
datum.Value = 1;
}
datum.AddMetadata("awsAccount", payload.AwsAccount);
datum.AddMetadata("awsRegion", payload.AwsRegion);
metrics.Data.Add(datum);
telemetryLogger.Record(metrics);
}
catch (System.Exception e)
{
telemetryLogger.Logger.Error("Error recording telemetry event", e);
System.Diagnostics.Debug.Assert(false, "Error Recording Telemetry");
}
}
/// <summary>
/// Evaluates if the exception is handleable, i.e., can be continued upon.
/// The associated exception metric is logged.
/// </summary>
/// <param name="ex">Exception that is to be evaluated as handleable or not.</param>
/// <param name="logger">Telemetry logger used to log the exception/metric.</param>
/// <param name="handledExceptionMetric">Exception metric that is to be logged if the passed in exception is handled and not of type ITelemetryFormattable.</param>
/// <param name="unhandledExceptionMetric">Exception metric that is to be logged if the passed in exception is unhandled and not of type ITelemetryFormattable.</param>
/// <returns>Returns true if the exception is handleable, i.e., can be continued upon. False otherwise.</returns>
protected bool HandleException(
Exception ex,
ITelemetryLogger logger,
Metric handledExceptionMetric = null,
Metric unhandledExceptionMetric = null)
{
EnsureArg.IsNotNull(ex, nameof(ex));
EnsureArg.IsNotNull(logger, nameof(logger));
var exType = ex.GetType();
var lookupType = exType.IsGenericType ? exType.GetGenericTypeDefinition() : exType;
if (_handledExceptions.Contains(lookupType))
{
LogExceptionMetric(ex, logger, handledExceptionMetric);
return(true);
}
logger.LogError(ex);
LogExceptionMetric(ex, logger, unhandledExceptionMetric);
return(false);
}
public MigrationEngine(
IServiceProvider services,
IOptions <NetworkCredentialsOptions> networkCredentials,
IOptions <EngineConfiguration> config,
TypeDefinitionMapContainer typeDefinitionMaps,
ProcessorContainer processors,
GitRepoMapContainer gitRepoMaps,
ChangeSetMappingContainer changeSetMapps,
FieldMapContainer fieldMaps,
ITelemetryLogger telemetry,
ILogger <MigrationEngine> logger)
{
_logger = logger;
_logger.LogInformation("Creating Migration Engine {SessionId}", telemetry.SessionId);
_services = services;
FieldMaps = fieldMaps;
_networkCredentials = networkCredentials.Value;
TypeDefinitionMaps = typeDefinitionMaps;
Processors = processors;
GitRepoMaps = gitRepoMaps;
ChangeSetMapps = changeSetMapps;
Telemetry = telemetry;
Config = config.Value;
}
public New3Command(string commandName, ITemplateEngineHost host, ITelemetryLogger telemetryLogger, New3Callbacks callbacks, INewCommandInput commandInput, string hivePath)
{
_telemetryLogger = telemetryLogger;
host = new ExtendedTemplateEngineHost(host, this);
EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x), hivePath);
_settingsLoader = (SettingsLoader)EnvironmentSettings.SettingsLoader;
Installer = new Installer(EnvironmentSettings);
_templateCreator = new TemplateCreator(EnvironmentSettings);
_aliasRegistry = new AliasRegistry(EnvironmentSettings);
CommandName = commandName;
_paths = new Paths(EnvironmentSettings);
_hostDataLoader = new HostSpecificDataLoader(EnvironmentSettings.SettingsLoader);
_commandInput = commandInput;
_callbacks = callbacks;
if (callbacks == null)
{
callbacks = new New3Callbacks();
}
if (!EnvironmentSettings.Host.TryGetHostParamDefault("prefs:language", out _defaultLanguage))
{
_defaultLanguage = null;
}
}
public TfsTeamSettingsProcessor(ProcessorEnricherContainer processorEnrichers,
IEndpointFactory endpointFactory,
IServiceProvider services,
ITelemetryLogger telemetry,
ILogger <Processor> logger)
: base(processorEnrichers, endpointFactory, services, telemetry, logger)
{
_targetTeamFoundationIdentitiesLazyCache = new Lazy <List <TeamFoundationIdentity> >(() =>
{
try
{
TfsTeamService teamService = Target.TfsTeamService;
var identityService = Target.TfsCollection.GetService <IIdentityManagementService>();
var tfi = identityService.ReadIdentity(IdentitySearchFactor.General, "Project Collection Valid Users", MembershipQuery.Expanded, ReadIdentityOptions.None);
return(identityService.ReadIdentities(tfi.Members, MembershipQuery.None, ReadIdentityOptions.None).ToList());
}
catch (Exception ex)
{
Log.LogError(ex, "{LogTypeName}: Unable load list of identities from target collection.", LogTypeName);
return(new List <TeamFoundationIdentity>());
}
});
}
public static int Run(string commandName, ITemplateEngineHost host, ITelemetryLogger telemetryLogger, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, string[] args, string hivePath)
{
if (!args.Any(x => string.Equals(x, "--debug:ephemeral-hive")))
{
EnsureEntryMutex(hivePath, host);
if (!_entryMutex.WaitOne())
{
return(-1);
}
}
try
{
return(ActualRun(commandName, host, telemetryLogger, onFirstRun, args, hivePath));
}
finally
{
if (_entryMutex != null)
{
_entryMutex.ReleaseMutex();
}
}
}
public static int Run(string commandName, ITemplateEngineHost host, ITelemetryLogger telemetryLogger, New3Callbacks callbacks, string[] args, string hivePath)
{
if (!args.Any(x => string.Equals(x, "--debug:ephemeral-hive")))
{
EnsureEntryMutex(hivePath, host);
if (!_entryMutex.WaitOne())
{
return(-1);
}
}
try
{
return(ActualRun(commandName, host, telemetryLogger, callbacks, args, hivePath));
}
finally
{
if (_entryMutex != null)
{
_entryMutex.ReleaseMutex();
}
}
}
public DeflateDiskSaver(
IDeflater deflater,
string folder,
TimeSpan border,
ITelemetryLogger logger
)
{
if (deflater == null)
{
throw new ArgumentNullException("deflater");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
//folder allowed to be null
if (border.TotalSeconds >= 0)
{
throw new ArgumentException("border must be less than zero. Recommended value is -1 month.");
}
_deflater = deflater;
_logger = logger;
_folder = string.IsNullOrEmpty(folder) ? "PerfLog" : folder;
_border = border;
//создаем папку, если не создано
CreateIfNotExists();
//удаляем старье
DeleteOld();
//читаем актуальные параметры
ReadConfig();
//следующая папка при каждом старте сейвера
CheckForNextFolder();
}
public static CreationResultStatus HandleParseError(INewCommandInput commandInput, ITelemetryLogger telemetryLogger)
{
TemplateListResolver.ValidateRemainingParameters(commandInput, out IReadOnlyList <string> invalidParams);
DisplayInvalidParameters(invalidParams);
// TODO: get a meaningful error message from the parser
if (commandInput.IsHelpFlagSpecified)
{
// this code path doesn't go through the full help & usage stack, so needs it's own call to ShowUsageHelp().
ShowUsageHelp(commandInput, telemetryLogger);
}
else
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.RunHelpForInformationAboutAcceptedParameters, commandInput.CommandName).Bold().Red());
}
return(CreationResultStatus.InvalidParamValues);
}
private static CreationResultStatus DisplayHelpForAmbiguousTemplateGroup(TemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, string defaultLanguage)
{
// The following occurs when:
// --alias <value> is specifed
// --help is specified
// template (group) can't be resolved
if (!string.IsNullOrWhiteSpace(commandInput.Alias))
{
Reporter.Error.WriteLine(LocalizableStrings.InvalidInputSwitch.Bold().Red());
Reporter.Error.WriteLine(" " + commandInput.TemplateParamInputFormat("--alias").Bold().Red());
return(CreationResultStatus.NotFound);
}
bool hasInvalidParameters = false;
IReadOnlyList <ITemplateMatchInfo> templatesForDisplay = templateResolutionResult.GetBestTemplateMatchList(true);
GetParametersInvalidForTemplatesInList(templatesForDisplay, out IReadOnlyList <string> invalidForAllTemplates, out IReadOnlyList <string> invalidForSomeTemplates);
if (invalidForAllTemplates.Any() || invalidForSomeTemplates.Any())
{
hasInvalidParameters = true;
DisplayInvalidParameters(invalidForAllTemplates);
DisplayParametersInvalidForSomeTemplates(invalidForSomeTemplates, LocalizableStrings.PartialTemplateMatchSwitchesNotValidForAllMatches);
}
ShowContextAndTemplateNameMismatchHelp(templateResolutionResult, commandInput.TemplateName, commandInput.Language, commandInput.TypeFilter, out bool shouldShowTemplateList);
if (shouldShowTemplateList)
{
ShowTemplatesFoundMessage(commandInput.TemplateName, commandInput.Language, commandInput.TypeFilter);
DisplayTemplateList(templatesForDisplay, environmentSettings, commandInput.Language, defaultLanguage);
}
if (!commandInput.IsListFlagSpecified)
{
TemplateUsageHelp.ShowInvocationExamples(templateResolutionResult, hostDataLoader, commandInput.CommandName);
}
if (hasInvalidParameters)
{
return(CreationResultStatus.NotFound);
}
else if (commandInput.IsListFlagSpecified || commandInput.IsHelpFlagSpecified)
{
return(shouldShowTemplateList ? CreationResultStatus.Success : CreationResultStatus.NotFound);
}
else
{
return(CreationResultStatus.OperationNotSpecified);
}
}
public TemplateInvoker(IEngineEnvironmentSettings environment, INewCommandInput commandInput, ITelemetryLogger telemetryLogger, string commandName, Func <string> inputGetter, New3Callbacks callbacks)
{
_environment = environment;
_commandInput = commandInput;
_telemetryLogger = telemetryLogger;
_commandName = commandName;
_inputGetter = inputGetter;
_callbacks = callbacks;
_templateCreator = new TemplateCreator(_environment);
_hostDataLoader = new HostSpecificDataLoader(_environment.SettingsLoader);
}
public Processor(IServiceProvider services, ITelemetryLogger telemetry, ILogger <Processor> logger)
{
Services = services;
Telemetry = telemetry;
Log = logger;
}
public WorkItemLinkEnricher(IServiceProvider services, ITelemetryLogger telemetry, ILogger <WorkItemLinkEnricher> logger) : base(services, telemetry, logger)
{
}
public WorkItemMigrationClientBase(IServiceProvider services, ITelemetryLogger telemetry)
{
Services = services;
Telemetry = telemetry;
}
public static void DoCleanup(
SqlConnection connection,
SqlTransaction transaction,
string databaseName,
string tableName,
long aliveRowsCount,
ITelemetryLogger logger
)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
//transaction allowed to be null
if (databaseName == null)
{
throw new ArgumentNullException("databaseName");
}
if (tableName == null)
{
throw new ArgumentNullException("tableName");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (aliveRowsCount <= 0)
{
throw new ArgumentException("aliveRowsCount <= 0");
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before Cleanup");
var deleteOldClause = DeleteOldClause.Replace("{_DatabaseName_}", databaseName);
deleteOldClause = deleteOldClause.Replace("{_TableName_}", tableName);
deleteOldClause = deleteOldClause.Replace("{_Barrier_}", aliveRowsCount.ToString(CultureInfo.InvariantCulture));
using (var cmd = new System.Data.SqlClient.SqlCommand(deleteOldClause, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry After Cleanup");
}
private void InitializeTelemetry() {
var thisAssembly = typeof(NodejsPackage).Assembly;
// Get telemetry logger
_telemetryLogger = TelemetrySetup.Instance.GetLogger(thisAssembly);
TelemetrySetup.Instance.LogPackageLoad(_telemetryLogger, Guid.Parse(Guids.NodejsPackageString), thisAssembly, Application.ProductVersion);
}
public static StackIdContainer ReadStackTable(
SqlConnection connection,
SqlTransaction transaction,
string databaseName,
string tableName,
ITelemetryLogger logger
)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
//transaction allowed to be null
if (databaseName == null)
{
throw new ArgumentNullException("databaseName");
}
if (tableName == null)
{
throw new ArgumentNullException("tableName");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
var result = new StackIdContainer();
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before ReadStackTable");
var readStackClause = ReadStackTableClause.Replace("{_DatabaseName_}", databaseName);
readStackClause = readStackClause.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(readStackClause, connection, transaction))
{
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var id = (int)reader["id"];
var key = (string)reader["key"];
result.ForceAdd(key, id);
}
}
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry After ReadStackTable");
return
result;
}
public SqlBatchItemSaverFactory(
ITelemetryLogger logger,
string connectionString,
string databaseName,
string tableName,
long aliveRowsCount
)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (connectionString == null)
{
throw new ArgumentNullException("connectionString");
}
if (databaseName == null)
{
throw new ArgumentNullException("databaseName");
}
if (aliveRowsCount <= 0)
{
throw new ArgumentException("aliveRowsCount <= 0");
}
_logger = logger;
_connectionString = connectionString;
_databaseName = databaseName;
_tableName = tableName;
_aliveRowsCount = aliveRowsCount;
try
{
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
long lastRowId;
SqlHelper.DoPreparation(
connection,
null,
_databaseName,
_tableName,
_logger,
out lastRowId
);
_stackIdContainer = SqlHelper.ReadStackTable(
connection,
null,
_databaseName,
_tableName,
_logger
);
_lastRowIdContainer = new LastRowIdContainer(lastRowId);
}
}
catch(Exception excp)
{
_safeMode = true;
logger.LogHandledException(
this.GetType(),
"Error database patching. Telemetry is going offline.",
excp
);
}
}
public TeamMigrationContext(IMigrationEngine engine, IServiceProvider services, ITelemetryLogger telemetry, ILogger <TeamMigrationContext> logger) : base(engine, services, telemetry, logger)
{
}
protected override Task <NewCommandStatus> ExecuteAsync(InstallCommandArgs args, IEngineEnvironmentSettings environmentSettings, ITelemetryLogger telemetryLogger, InvocationContext context)
{
PrintDeprecationMessage <LegacyInstallCommand, InstallCommand>(args.ParseResult);
return(base.ExecuteAsync(args, environmentSettings, telemetryLogger, context));
}
public static List <IEventConsumer> GetEventConsumers(IConfiguration config, string inputEventHub, ServiceProvider sp, ITelemetryLogger logger)
{
var eventConsumers = new List <IEventConsumer>();
var templateOptions = new TemplateOptions();
config.GetSection(TemplateOptions.Settings).Bind(templateOptions);
EnsureArg.IsNotNull(templateOptions);
EnsureArg.IsNotNull(templateOptions.BlobContainerName);
EnsureArg.IsNotNull(templateOptions.BlobStorageConnectionString);
var storageManager = new StorageManager(
templateOptions.BlobStorageConnectionString,
templateOptions.BlobContainerName);
var templateManager = new TemplateManager(storageManager);
if (inputEventHub == "devicedata")
{
var template = config.GetSection("Template:DeviceContent").Value;
var deviceDataNormalization = new Normalize.Processor(template, templateManager, config, sp.GetRequiredService <IOptions <EventHubMeasurementCollectorOptions> >(), logger);
eventConsumers.Add(deviceDataNormalization);
}
else if (inputEventHub == "normalizeddata")
{
var template = config.GetSection("Template:FhirMapping").Value;
var measurementImportService = ResolveMeasurementService(sp);
var measurementToFhirConsumer = new MeasurementCollectionToFhir.Processor(template, templateManager, measurementImportService, logger);
eventConsumers.Add(measurementToFhirConsumer);
}
if (config.GetSection("Console:Debug")?.Value == "true")
{
eventConsumers.Add(new EventPrinter());
}
return(eventConsumers);
}
public GatewayChannel(IEndPointBinding binding, ITelemetryLogger logger)
{
_binding = binding;
_logger = logger;
}
public static bool DoPreparation(
SqlConnection connection,
SqlTransaction transaction,
string databaseName,
string tableName,
ITelemetryLogger logger,
out long lastRowId
)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
//transaction allowed to be null
if (databaseName == null)
{
throw new ArgumentNullException("databaseName");
}
if (tableName == null)
{
throw new ArgumentNullException("tableName");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
var exist = false;
lastRowId = 0L;
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before preparation");
var clause0 = PreparationClause0.Replace("{_DatabaseName_}", databaseName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause0, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 1");
var clause1 = PreparationClause1.Replace("{_DatabaseName_}", databaseName);
clause1 = clause1.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause1, connection, transaction))
{
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
lastRowId = (long)reader[0];
exist = (bool)reader[1];
break;
}
}
}
logger.LogMessage(typeof(SqlHelper), string.Format("PerformanceTelemetry exist = {0}", exist));
logger.LogMessage(typeof(SqlHelper), string.Format("PerformanceTelemetry last row Id = {0}", lastRowId));
if (!exist)
{
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 2");
var clause2 = PreparationClause2.Replace("{_DatabaseName_}", databaseName);
clause2 = clause2.Replace("{_ClassNameMaxLength_}", ClassNameMaxLength.ToString(CultureInfo.InvariantCulture));
clause2 = clause2.Replace("{_MethodNameMaxLength_}", MethodNameMaxLength.ToString(CultureInfo.InvariantCulture));
clause2 = clause2.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause2, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 3");
var clause3 = PreparationClause3.Replace("{_DatabaseName_}", databaseName);
clause3 = clause3.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause3, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 4");
var clause4 = PreparationClause4.Replace("{_DatabaseName_}", databaseName);
clause4 = clause4.Replace("{_TableName_}", tableName);
clause4 = clause4.Replace("{_ExceptionMessageMaxLength_}", ExceptionMessageMaxLength.ToString(CultureInfo.InvariantCulture));
using (var cmd = new System.Data.SqlClient.SqlCommand(clause4, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 5");
var clause5 = PreparationClause5.Replace("{_DatabaseName_}", databaseName);
clause5 = clause5.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause5, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 6");
var clause6 = PreparationClause6.Replace("{_DatabaseName_}", databaseName);
clause6 = clause6.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause6, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 7");
var clause7 = PreparationClause7.Replace("{_DatabaseName_}", databaseName);
clause7 = clause7.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause7, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 8");
var clause8 = PreparationClause8.Replace("{_DatabaseName_}", databaseName);
clause8 = clause8.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause8, connection, transaction))
{
cmd.ExecuteNonQuery();
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Before clause 9");
var clause9 = PreparationClause9.Replace("{_DatabaseName_}", databaseName);
clause9 = clause9.Replace("{_TableName_}", tableName);
using (var cmd = new System.Data.SqlClient.SqlCommand(clause9, connection, transaction))
{
cmd.ExecuteNonQuery();
}
}
logger.LogMessage(typeof(SqlHelper), "PerformanceTelemetry Preparation Finished!");
return
exist;
}
public StartupService(IHostApplicationLifetime lifeTime, IDetectOnlineService detectOnlineService, IDetectVersionService detectVersionService, ILogger <StartupService> logger, ITelemetryLogger telemetryLogger)
{
_LifeTime = lifeTime;
_detectOnlineService = detectOnlineService;
_detectVersionService = detectVersionService;
_logger = logger;
_telemetryLogger = telemetryLogger;
}
public WorkItemEmbedEnricher(IServiceProvider services, ITelemetryLogger telemetry, ILogger <WorkItemEndpointEnricher> logger) : base(services, telemetry, logger)
{
}
public DetectOnlineService(ITelemetryLogger telemetry)
{
_Telemetry = telemetry;
}
public MeasurementEventNormalizationService(ITelemetryLogger log, IContentTemplate contentTemplate)
: this(log, contentTemplate, new EventDataWithJsonBodyToJTokenConverter(), 3)
{
}
public WorkItemEndpointEnricher(IServiceProvider services, ITelemetryLogger telemetry, ILogger <WorkItemEndpointEnricher> logger)
{
Services = services;
Telemetry = telemetry;
Log = logger;
}
protected MigrationProcessorBase(IMigrationEngine engine, IServiceProvider services, ITelemetryLogger telemetry, ILogger <MigrationProcessorBase> logger)
{
Engine = engine;
Services = services;
Telemetry = telemetry;
Log = logger;
}
public static CreationResultStatus CoordinateHelpAndUsageDisplay(TemplateListResolutionResult templateResolutionResult, IEngineEnvironmentSettings environmentSettings, INewCommandInput commandInput, IHostSpecificDataLoader hostDataLoader, ITelemetryLogger telemetryLogger, TemplateCreator templateCreator, string defaultLanguage, bool showUsageHelp = true)
{
if (showUsageHelp)
{
ShowUsageHelp(commandInput, telemetryLogger);
}
// this is just checking if there is an unambiguous group.
// the called methods decide whether to get the default language filtered lists, based on what they're doing.
//
// The empty TemplateName check is for when only 1 template (or group) is installed.
// When that occurs, the group is considered partial matches. But the output should be the ambiguous case - list the templates, not help on the singular group.
if (!string.IsNullOrEmpty(commandInput.TemplateName) &&
templateResolutionResult.TryGetUnambiguousTemplateGroupToUse(out IReadOnlyList <ITemplateMatchInfo> unambiguousTemplateGroup) &&
TemplateListResolver.AreAllTemplatesSameLanguage(unambiguousTemplateGroup))
{
// This will often show detailed help on the template group, which only makes sense if they're all the same language.
return(DisplayHelpForUnambiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, templateCreator, defaultLanguage));
}
else
{
return(DisplayHelpForAmbiguousTemplateGroup(templateResolutionResult, environmentSettings, commandInput, hostDataLoader, telemetryLogger, defaultLanguage));
}
}
public CreateTeamFolders(IServiceProvider services, IMigrationEngine me, ITelemetryLogger telemetry, ILogger <CreateTeamFolders> logger) : base(services, me, telemetry, logger)
{
}
public TfsEndpoint(EndpointEnricherContainer endpointEnrichers, IServiceProvider services, ITelemetryLogger telemetry, ILogger <Endpoint> logger) : base(endpointEnrichers, services, telemetry, logger)
{
}
internal SqlBatchItemSaver(
ITelemetryLogger logger,
StackIdContainer stackIdContainer,
string connectionString,
string databaseName,
string tableName,
long aliveRowsCount,
LastRowIdContainer lastRowIdContainer
)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (stackIdContainer == null)
{
throw new ArgumentNullException("stackIdContainer");
}
if (connectionString == null)
{
throw new ArgumentNullException("connectionString");
}
if (databaseName == null)
{
throw new ArgumentNullException("databaseName");
}
if (tableName == null)
{
throw new ArgumentNullException("tableName");
}
if (lastRowIdContainer == null)
{
throw new ArgumentNullException("lastRowIdContainer");
}
if (aliveRowsCount <= 0)
{
throw new ArgumentException("aliveRowsCount <= 0");
}
_logger = logger;
_stackIdContainer = stackIdContainer;
_databaseName = databaseName;
_tableName = tableName;
_aliveRowsCount = aliveRowsCount;
_lastRowIdContainer = lastRowIdContainer;
var connection = new SqlConnection(connectionString);
connection.Open();
try
{
var transaction = connection.BeginTransaction(IsolationLevel.Snapshot);
_connection = connection;
_transaction = transaction;
}
catch
{
#region close connection
if (this._connection != null)
{
try
{
this._connection.Close();
}
catch (Exception excp)
{
_logger.LogHandledException(this.GetType(), "ќшибка закрыти¤ конекшена в конструкторе", excp);
}
}
if (this._connection != null)
{
try
{
this._connection.Dispose();
}
catch (Exception excp)
{
_logger.LogHandledException(this.GetType(), "ќшибка утилизации конекшена в конструкторе", excp);
}
}
#endregion
throw;
}
var insertStackClause = InsertStackClause.Replace(
"{_TableName_}",
_tableName
);
_insertStackCommand = new System.Data.SqlClient.SqlCommand(insertStackClause, _connection, _transaction);
_insertStackCommand.Parameters.Add("class_name", SqlDbType.VarChar, SqlHelper.ClassNameMaxLength);
_insertStackCommand.Parameters.Add("method_name", SqlDbType.VarChar, SqlHelper.MethodNameMaxLength);
_insertStackCommand.Parameters.Add("creation_stack", SqlDbType.VarChar, -1);
_insertStackCommand.Parameters.Add("key", SqlDbType.VarChar, -1);
_insertStackCommand.Prepare();
_targetTable = new DataTable();
_targetTable.Columns.Add("id", typeof(long));
_targetTable.Columns.Add("date_commit", typeof(DateTime));
_targetTable.Columns.Add("id_parent", typeof(long));
_targetTable.Columns.Add("start_time", typeof(DateTime));
_targetTable.Columns.Add("exception_message", typeof(string));
_targetTable.Columns.Add("exception_stack", typeof(string));
_targetTable.Columns.Add("time_interval", typeof(float));
_targetTable.Columns.Add("id_stack", typeof(int));
_targetTable.Columns.Add("exception_full_text", typeof(string));
//создаем копировщик
_copier = new SqlBulkCopy(
connection,
SqlBulkCopyOptions.TableLock
//| SqlBulkCopyOptions.FireTriggers
//| SqlBulkCopyOptions.UseInternalTransaction
,
_transaction
);
_copier.DestinationTableName = tableName;
}
public PerformanceContainer(
ITelemetryLogger logger,
IPerformanceRecordFactory factory,
IPerformanceSaver saver)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (saver == null)
{
throw new ArgumentNullException("saver");
}
_logger = logger;
_factory = factory;
_saver = saver;
_activeRecordDict = new ConcurrentDictionary<int, IPerformanceRecord>();
}
public ImportProfilePictureContext(IServiceProvider services, IMigrationEngine me, ITelemetryLogger telemetry, ILogger <ImportProfilePictureContext> logger) : base(services, me, telemetry, logger)
{
//http://www.codeproject.com/Articles/18102/Howto-Almost-Everything-In-Active-Directory-via-C
ims2 = (IIdentityManagementService2)me.Target.GetService <IIdentityManagementService2>();
}
