public static DeploymentStatusFile Open(string id, IEnvironment environment, IAnalytics analytics, IOperationLock statusLock)
        {
            return statusLock.LockOperation(() =>
            {
                string path = Path.Combine(environment.DeploymentsPath, id, StatusFile);

                if (!FileSystemHelpers.FileExists(path))
                {
                    return null;
                }

                try
                {
                    XDocument document = null;
                    using (var stream = FileSystemHelpers.OpenRead(path))
                    {
                        document = XDocument.Load(stream);
                    }

                    return new DeploymentStatusFile(id, environment, statusLock, document);
                }
                catch (Exception ex)
                {
                    // in the scenario where w3wp is abruptly terminated while xml is being written,
                    // we may end up with corrupted xml.  we will handle the error and remove the problematic directory.
                    analytics.UnexpectedException(ex);

                    FileSystemHelpers.DeleteDirectorySafe(Path.GetDirectoryName(path), ignoreErrors: true);

                    // it is ok to return null as callers already handle null.
                    return null;
                }
            }, DeploymentStatusManager.LockTimeout);
        }

 public StructuredTextLogger(string path, IAnalytics analytics)
 {
     _depth = 0;
     _path = path;
     _analytics = analytics;
     _structuredTextDocument = new StructuredTextDocument<LogEntry>(path,
         // DateTime.ToString("o") => "2015-08-04T00:08:38.5489308Z"
         e => string.Join(LogEntrySeparator, e.LogTime.ToString("o"), e.Message, e.Id, (int)e.Type),
         str =>
         {
             var splitted = str.Split(new[] { LogEntrySeparator }, StringSplitOptions.None);
             if (splitted.Length == 4)
             {
                 var time = DateTime.Parse(splitted[0]).ToUniversalTime();
                 var message = UnsanitizeValue(splitted[1]);
                 var id = splitted[2];
                 var type = (LogEntryType)Int32.Parse(splitted[3]);
                 return new LogEntry(time, id, message, type);
             }
             else
             {
                 throw new FormatException(string.Format("the log line \"{0}\" is in an invalid format", str));
             }
         });
 }

        public TriggeredJobsScheduler(ITriggeredJobsManager triggeredJobsManager, ITraceFactory traceFactory, IAnalytics analytics, IEnvironment environment)
        {
            _triggeredJobsManager = triggeredJobsManager;
            _traceFactory = traceFactory;
            _environment = environment;

            _jobsFileWatcher = new JobsFileWatcher(triggeredJobsManager.JobsBinariesPath, OnJobChanged, JobSettings.JobSettingsFileName, ListJobNames, traceFactory, analytics);
        }

 public SiteExtensionController(ISiteExtensionManager manager, IEnvironment environment, ITraceFactory traceFactory, IAnalytics analytics)
 {
     _manager = manager;
     _environment = environment;
     _traceFactory = traceFactory;
     _analytics = analytics;
     _siteExtensionRoot = Path.Combine(_environment.RootPath, "SiteExtensions");
 }

        public DynamicsCrmConnector(ICrmServiceWrapper crmService, ILogger logger, IAnalytics analytics)
        {
            _crmService = crmService;
             _logger = logger;
             _analytics = analytics;

             DynamicsMapper.Configure();
        }

        public ContinuousJobRunner(string jobName, IEnvironment environment, IFileSystem fileSystem, IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
            : base(jobName, Constants.ContinuousPath, environment, fileSystem, settings, traceFactory, analytics)
        {
            _continuousJobLogger = new ContinuousJobLogger(jobName, Environment, FileSystem, TraceFactory);

            _disableFilePath = Path.Combine(JobBinariesPath, "disable.job");
            _singletonFilePath = Path.Combine(JobBinariesPath, "singleton.job");
        }

        public TriggeredJobsScheduler(ITriggeredJobsManager triggeredJobsManager, ITraceFactory traceFactory, IEnvironment environment, IAnalytics analytics)
        {
            _triggeredJobsManager = triggeredJobsManager;
            _traceFactory = traceFactory;
            _environment = environment;
            _analytics = analytics;

            _triggeredJobsManager.RegisterExtraEventHandlerForFileChange(OnJobChanged);
        }

        public TriggeredJobSchedule(TriggeredJob triggeredJob, Action<TriggeredJobSchedule> onSchedule, TriggeredJobSchedulerLogger logger, IAnalytics analytics)
        {
            TriggeredJob = triggeredJob;
            _onSchedule = onSchedule;
            Logger = logger;
            _analytics = analytics;

            _timer = new Timer(OnTimer, triggeredJob, Timeout.Infinite, Timeout.Infinite);
        }

        public ContinuousJobRunner(ContinuousJob continuousJob, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
            : base(continuousJob.Name, Constants.ContinuousPath, environment, settings, traceFactory, analytics)
        {
            _continuousJobLogger = new ContinuousJobLogger(continuousJob.Name, Environment, TraceFactory);

            _disableFilePath = Path.Combine(continuousJob.JobBinariesRootPath, "disable.job");

            _singletonLock = new LockFile(Path.Combine(JobDataPath, "singleton.job.lock"), TraceFactory);
        }

 public DeploymentStatusManager(IEnvironment environment,
                                IAnalytics analytics,
                                IOperationLock statusLock)
 {
     _environment = environment;
     _analytics = analytics;
     _statusLock = statusLock;
     _activeFile = Path.Combine(environment.DeploymentsPath, Constants.ActiveDeploymentFile);
 }

        public SiteExtensionManager(IContinuousJobsManager continuousJobManager, ITriggeredJobsManager triggeredJobManager, IEnvironment environment, IDeploymentSettingsManager settings, ITraceFactory traceFactory, HttpContextBase context, IAnalytics analytics)
        {
            _rootPath = Path.Combine(environment.RootPath, "SiteExtensions");
            _baseUrl = context.Request.Url == null ? String.Empty : context.Request.Url.GetLeftPart(UriPartial.Authority).TrimEnd('/');

            _localRepository = GetSourceRepository(_rootPath);
            _continuousJobManager = continuousJobManager;
            _triggeredJobManager = triggeredJobManager;
            _environment = environment;
            _settings = settings;
            _traceFactory = traceFactory;
            _analytics = analytics;
        }

        protected BaseJobRunner(string jobName, string jobsTypePath, IEnvironment environment,
            IDeploymentSettingsManager settings, ITraceFactory traceFactory, IAnalytics analytics)
        {
            TraceFactory = traceFactory;
            Environment = environment;
            Settings = settings;
            JobName = jobName;
            _analytics = analytics;

            JobBinariesPath = Path.Combine(Environment.JobsBinariesPath, jobsTypePath, jobName);
            JobTempPath = Path.Combine(Environment.TempPath, Constants.JobsPath, jobsTypePath, jobName);
            JobDataPath = Path.Combine(Environment.DataPath, Constants.JobsPath, jobsTypePath, jobName);

            _externalCommandFactory = new ExternalCommandFactory(Environment, Settings, Environment.RepositoryPath);
        }

        /// <summary>
        /// Get Analytics Instance
        /// </summary>
        /// <param name="accountId">accountId, when you setup your app this would be generated for you.</param>
        /// <param name="applicationId">applicationId, when you setup your app this would be generated for you</param>
        /// <param name="applicationVersion"> applicationVersion, specify version of your app here, make sure you don't forget to update this</param>
        /// <param name="uploadType">uploadType how data is going to be uploaded, UploadType.WhileUsingAsync | UploadType.Manual</param>
        /// <returns>iAnalytics new or cached instance</returns>
        /// <see cref="Integration Guidelines SDK Document"/>
        public static IAnalytics GetInstance()
        {
            lock (objectToLock)
            {
                if (iAnalytics == null)
                {
                    #if DEBUG
                    System.Diagnostics.Debug.WriteLine("created new analytics instance");
                    #endif

                    iAnalytics = new Analytics();
                }
            }

            return iAnalytics;
        }

 public DeploymentController(ITracer tracer,
                             IEnvironment environment,
                             IAnalytics analytics,
                             IDeploymentManager deploymentManager,
                             IDeploymentStatusManager status,
                             IOperationLock deploymentLock,
                             IRepositoryFactory repositoryFactory,
                             IAutoSwapHandler autoSwapHandler)
 {
     _tracer = tracer;
     _environment = environment;
     _analytics = analytics;
     _deploymentManager = deploymentManager;
     _status = status;
     _deploymentLock = deploymentLock;
     _repositoryFactory = repositoryFactory;
     _autoSwapHandler = autoSwapHandler;
 }

 public DeploymentManager(ISiteBuilderFactory builderFactory,
                          IEnvironment environment,
                          ITraceFactory traceFactory,
                          IAnalytics analytics,
                          IDeploymentSettingsManager settings,
                          IDeploymentStatusManager status,
                          IOperationLock deploymentLock,
                          ILogger globalLogger,
                          IWebHooksManager hooksManager)
 {
     _builderFactory = builderFactory;
     _environment = environment;
     _traceFactory = traceFactory;
     _analytics = analytics;
     _deploymentLock = deploymentLock;
     _globalLogger = globalLogger ?? NullLogger.Instance;
     _settings = settings;
     _status = status;
     _hooksManager = hooksManager;
 }

        public JobsFileWatcher(
            string watchedDirectoryPath,
            Action<string> onJobChanged,
            string filter,
            Func<IEnumerable<string>> listJobNames,
            ITraceFactory traceFactory,
            IAnalytics analytics)
        {
            _traceFactory = traceFactory;
            _analytics = analytics;
            _watchedDirectoryPath = watchedDirectoryPath;
            _onJobChanged = onJobChanged;
            _filter = filter;
            _listJobNames = listJobNames;

            _makeChangesTimer = new Timer(OnMakeChanges);
            _startFileWatcherTimer = new Timer(StartWatcher);
            _startFileWatcherTimer.Change(0, Timeout.Infinite);

            FirstTimeMakingChanges = true;
        }

            public JobStartedReporter(IAnalytics analytics, JobBase job, string trigger, string siteMode, string jobDataPath)
            {
                _analytics = analytics;
                _job = job;
                _trigger = trigger;
                _siteMode = siteMode;
                _jobDataPath = jobDataPath;

                _timer = new Timer(Report, null, ReportTimeoutInMilliseconds, Timeout.Infinite);
            }

 public XmlLogger(IFileSystem fileSystem, string path, IAnalytics analytics)
 {
     _fileSystem = fileSystem;
     _path = path;
     _analytics = analytics;
 }

        internal static void UpdateAppConfig(string configFilePath, IAnalytics analytics)
        {
            try
            {
                var settings = SettingsProcessor.Instance;

                bool updateXml = false;

                // Read app.config
                string exeFilePath = configFilePath.Substring(0, configFilePath.Length - ".config".Length);

                // Only continue to update config file if the corresponding exe file exists
                if (!FileSystemHelpers.FileExists(exeFilePath))
                {
                    return;
                }

                // save the LastWriteTime before our modification, so we can restore
                // it below
                FileInfo fileInfo = new FileInfo(configFilePath);
                DateTime lastWriteTime = fileInfo.LastWriteTimeUtc;

                Configuration config = ConfigurationManager.OpenExeConfiguration(exeFilePath);

                foreach (var appSetting in settings.AppSettings)
                {
                    config.AppSettings.Settings.Remove(appSetting.Key);
                    config.AppSettings.Settings.Add(appSetting.Key, appSetting.Value);
                    updateXml = true;
                }

                foreach (ConnectionStringSettings connectionString in settings.ConnectionStrings)
                {
                    ConnectionStringSettings currentConnectionString = config.ConnectionStrings.ConnectionStrings[connectionString.Name];
                    if (currentConnectionString != null)
                    {
                        // Update provider name if connection string already exists and provider name is null (custom type)
                        connectionString.ProviderName = connectionString.ProviderName ?? currentConnectionString.ProviderName;
                    }

                    config.ConnectionStrings.ConnectionStrings.Remove(connectionString.Name);
                    config.ConnectionStrings.ConnectionStrings.Add(connectionString);

                    updateXml = true;
                }

                if (updateXml)
                {
                    // Write updated app.config
                    config.Save();
                }

                // we need to restore the previous last update time so our file write
                // doesn't cause the job directory to be considered dirty
                fileInfo.LastWriteTimeUtc = lastWriteTime;
            }
            catch (Exception ex)
            {
                analytics.UnexpectedException(ex);
            }
        }

        /// <summary>
        /// Updates the app.config using XML directly for injecting trace providers.
        /// </summary>
        internal static void UpdateAppConfigAddTraceListeners(string configFilePath, IAnalytics analytics)
        {
            try
            {
                var xmlConfig = XDocument.Load(configFilePath);

                // save the LastWriteTime before our modification, so we can restore
                // it below
                FileInfo fileInfo = new FileInfo(configFilePath);
                DateTime lastWriteTime = fileInfo.LastWriteTimeUtc;

                // Make sure the trace listeners section available otherwise create it
                var configurationElement = GetOrCreateElement(xmlConfig, "configuration");
                var systemDiagnosticsElement = GetOrCreateElement(configurationElement, "system.diagnostics");
                var traceElement = GetOrCreateElement(systemDiagnosticsElement, "trace");
                var listenersElement = GetOrCreateElement(traceElement, "listeners");

                // Inject existing trace providers to the target app.config
                foreach (TraceListener listener in Trace.Listeners)
                {
                    // Ignore the default trace provider
                    if (String.Equals(listener.Name, "default", StringComparison.OrdinalIgnoreCase))
                    {
                        continue;
                    }

                    // Do not add a trace provider if it already exists (by name)
                    XElement listenerElement = listenersElement.Elements().FirstOrDefault(xElement =>
                    {
                        XAttribute nameAttribute = xElement.Attribute("name");
                        return nameAttribute != null && String.Equals(nameAttribute.Value, listener.Name, StringComparison.OrdinalIgnoreCase);
                    });

                    if (listenerElement == null)
                    {
                        var addElement = new XElement("add");
                        addElement.Add(new XAttribute("name", listener.Name));
                        addElement.Add(new XAttribute("type", listener.GetType().AssemblyQualifiedName));
                        listenersElement.AddFirst(addElement);
                    }
                }

                FileSystemHelpers.WriteAllText(configFilePath, xmlConfig.ToString());

                // we need to restore the previous last update time so our file write
                // doesn't cause the job directory to be considered dirty
                fileInfo.LastWriteTimeUtc = lastWriteTime;
            }
            catch (Exception ex)
            {
                analytics.UnexpectedException(ex);
            }
        }