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>(); }