private static void EnsureName(MiniProfiler profiler, HttpRequest request)
        {
            // also set the profiler name to Controller/Action or /url
            if (string.IsNullOrWhiteSpace(profiler.Name))
            {
                var rc = request.RequestContext;
                RouteValueDictionary values;

                if (rc != null && rc.RouteData != null && (values = rc.RouteData.Values).Count > 0)
                {
                    var controller = values["Controller"];
                    var action = values["Action"];

                    if (controller != null && action != null)
                        profiler.Name = controller.ToString() + "/" + action.ToString();
                }

                if (string.IsNullOrWhiteSpace(profiler.Name))
                {
                    profiler.Name = request.Url.AbsolutePath ?? string.Empty;
                    if (profiler.Name.Length > 50)
                        profiler.Name = profiler.Name.Remove(50);
                }
            }
        }

        public void Write(MiniProfiler miniProfiler)
        {
            if (miniProfiler != null && miniProfiler.DurationMilliseconds > 50)
            {
                StringBuilder sb = new StringBuilder();

                // Write step times
                if (miniProfiler.Root.HasChildren)
                {
                    var children = miniProfiler.Root.Children;
                    foreach (var child in children)
                    {
                        sb.AppendLine(child.Name + " " + child.DurationMilliseconds);
                    }
                }

                // Write overall request time
                sb.AppendLine(string.Format("{0} {1}\n",
                    miniProfiler.DurationMilliseconds,
                    miniProfiler.Root));

                // Write to file
                try
                {
                    File.AppendAllText(@"c:\temp\out.txt", sb.ToString());
                }
                catch (Exception)
                {
                }
            }
        }

 public HomeController()
 {
     DbInitializer.Initialize();
     profiler = MiniProfiler.Current;
     EasternStandardTimeId = "Eastern Standard Time";
     ESTTimeZone = TimeZoneInfo.FindSystemTimeZoneById(EasternStandardTimeId);
 }

        public override MiniProfiler Start(ProfileLevel level, string sessionName = null)
        {
            var context = HttpContext.Current;
            if (context == null || context.Request.AppRelativeCurrentExecutionFilePath == null) return null;

            var url = context.Request.Url;
            var path = context.Request.AppRelativeCurrentExecutionFilePath.Substring(1).ToUpperInvariant();

            // don't profile /content or /scripts, either - happens in web.dev
            foreach (var ignored in MiniProfiler.Settings.IgnoredPaths ?? new string[0])
            {
                if (path.Contains((ignored ?? string.Empty).ToUpperInvariant()))
                    return null;
            }

            if (context.Request.Path.StartsWith(VirtualPathUtility.ToAbsolute(MiniProfiler.Settings.RouteBasePath), StringComparison.InvariantCultureIgnoreCase))
            {
                return null;
            }

            var result = new MiniProfiler(sessionName ?? url.OriginalString, level);
            Current = result;

            SetProfilerActive(result);

            // don't really want to pass in the context to MiniProfler's constructor or access it statically in there, either
            result.User = Settings.UserProvider.GetUser(context.Request);

            return result;
        }

 public override StackExchange.Profiling.MiniProfiler Start(ProfileLevel level, string sessionName = null)
 {
     _profiler = new StackExchange.Profiling.MiniProfiler(ConsoleProfiling.ProfilingUrl(), level);
     SetProfilerActive(_profiler);
     _profiler.User = ConsoleProfiling.CurrentUser();
     return _profiler;
 }

        /// <summary>
        /// Stores <paramref name="profiler"/> under its <see cref="P:StackExchange.Profiling.MiniProfiler.Id"/>.
        /// </summary>
        /// <param name="profiler">The results of a profiling session.</param>
        /// <remarks>
        /// Should also ensure the profiler is stored as being un-viewed by its profiling <see cref="P:StackExchange.Profiling.MiniProfiler.User"/>.
        /// </remarks>
        public void Save(MiniProfiler profiler)
        {
            if (_log == null)
            {
                return;
            }

            switch (_profilerProfilerLevel)
            {
                case Log4NetLevels.Off:
                    //Off
                    return;
                case Log4NetLevels.Fatal:
                    _log.FatalExt(GetProfilerText(profiler));
                    break;
                case Log4NetLevels.Error:
                    _log.ErrorExt(GetProfilerText(profiler));
                    break;
                case Log4NetLevels.Warn:
                    _log.WarnExt(GetProfilerText(profiler));
                    break;
                case Log4NetLevels.Info:
                    _log.InfoExt(GetProfilerText(profiler));
                    break;
                case Log4NetLevels.Debug:
                    _log.DebugExt(GetProfilerText(profiler));
                    break;
            }
        }

        /// <summary>
        /// Sets <paramref name="profiler"/> to be active (read to start profiling)
        /// This should be called once a new MiniProfiler has been created.
        /// </summary>
        /// <exception cref="ArgumentNullException">If <paramref name="profiler"/> is null</exception>
        protected static void SetProfilerActive(MiniProfiler profiler)
        {
            if (profiler == null)
                throw new ArgumentNullException("profiler");

            profiler.IsActive = true;
        }

 /// <summary>
 /// Creates a new profiler for the current context, used for background tasks
 /// </summary>
 /// <param name="name">The name of the profiler to create</param>
 /// <param name="id">The Id of the profiler</param>
 public static MiniProfiler CreateContextProfiler(string name, Guid? id = null)
 {
     var profiler = new MiniProfiler(name);
     SetProfilerActive(profiler);
     if (id.HasValue) profiler.Id = id.Value;
     CallContext.LogicalSetData(LocalContextKey, profiler);
     return profiler;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="BlogController" /> class.
 /// </summary>
 /// <param name="blogRepository">The blog post repository.</param>
 /// <param name="commentRepository">The Disqus comment repository</param>
 /// <param name="urlShortener">The URL shortener</param>
 /// <param name="socialManager">The social network manager used to get sharing URLs</param>
 /// <param name="siteConfig">Site configuration</param>
 public BlogController(IBlogRepository blogRepository, IDisqusCommentRepository commentRepository, IUrlShortener urlShortener, ISocialManager socialManager, ISiteConfiguration siteConfig)
 {
     _blogRepository = blogRepository;
     _commentRepository = commentRepository;
     _urlShortener = urlShortener;
     _socialManager = socialManager;
     _siteConfig = siteConfig;
     _profiler = MiniProfiler.Current;
 }

 /// <summary>
 /// Calls <see cref="MiniProfiler.Settings.EnsureStorageStrategy"/> to save the current
 /// profiler using the current storage settings
 /// </summary>
 protected static void SaveProfiler(MiniProfiler current)
 {
     // because we fetch profiler results after the page loads, we have to put them somewhere in the meantime
     MiniProfiler.Settings.EnsureStorageStrategy();
     MiniProfiler.Settings.Storage.Save(current);
     if (current.HasUserViewed == false)
     {
         MiniProfiler.Settings.Storage.SetUnviewed(current.User, current.Id);
     }
 }

        /// <summary>
        /// Stops the profiler and marks it as inactive.
        /// </summary>
        /// <returns>True if successful, false if Stop had previously been called on this profiler</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="profiler"/> is null</exception>
        protected static bool StopProfiler(MiniProfiler profiler)
        {
            if (profiler == null)
                throw new ArgumentNullException("profiler");

            if (!profiler.StopImpl())
                return false;

            profiler.IsActive = false;
            return true;
        }

        public void GetProfiler()
        {
            var expectedProfiler = new MiniProfiler("http://fake");
            var storage = NSubstitute.Substitute.For<IStorage>();
            storage.Load(expectedProfiler.Id).Returns(expectedProfiler);

            MiniProfiler.Settings.Storage = storage;

            var controller = new ProfilerResultsController();
            var profiler = controller.Get(expectedProfiler.Id);

            Assert.AreEqual<MiniProfiler>(expectedProfiler, profiler);
        }

        /// <summary>
        /// Returns a new CustomTiming, also initializing its <see cref="Id"/> and, optionally, its <see cref="StackTraceSnippet"/>.
        /// </summary>
        public CustomTiming(MiniProfiler profiler, string commandString)
        {
            _profiler = profiler;
            _startTicks = profiler.ElapsedTicks;
            CommandString = commandString;

            Id = Guid.NewGuid();
            StartMilliseconds = profiler.GetRoundedMilliseconds(profiler.ElapsedTicks);

            if (!MiniProfiler.Settings.ExcludeStackTraceSnippetFromCustomTimings)
            {
                StackTraceSnippet = Helpers.StackTraceSnippet.Get();
            }
        }

        public void GetAllProfilerIdsWithDefaultParams()
        {
            var expectedProfilerIds = new List<Guid>();
            var profiler = new MiniProfiler("http://fake");
            expectedProfilerIds.Add(profiler.Id);
            var storage = NSubstitute.Substitute.For<IStorage>();
            storage.List(25).Returns(expectedProfilerIds);

            MiniProfiler.Settings.Storage = storage;
            
            var controller = new ProfilerResultsController();
            var profilerIds = controller.Get().ToList();

            Assert.AreEqual<Guid>(expectedProfilerIds.First(), profilerIds.First());
        }

        /// <summary>
        /// Starts a new MiniProfiler and sets it to be current.  By the end of this method
        ///             <see cref="M:StackExchange.Profiling.BaseProfilerProvider.GetCurrentProfiler"/> should return the new MiniProfiler.
        /// </summary>
        public override MiniProfiler Start(string sessionName = null)
        {
            _profiler = new MiniProfiler(sessionName ?? AppDomain.CurrentDomain.FriendlyName);
            if (IsLogEnabled(_logger, _profilerLogLevel))
            {
                SetProfilerActive(_profiler);
            }
            else
            {
                StopProfiler(_profiler);
            }


            return _profiler;
        }

        /// <summary>
        /// Creates a new Timing named 'name' in the 'profiler's session, with 'parent' as this Timing's immediate ancestor.
        /// </summary>
        public Timing(MiniProfiler profiler, Timing parent, string name)
        {
            this.Id = Guid.NewGuid();
            Profiler = profiler;
            Profiler.Head = this;

            if (parent != null) // root will have no parent
            {
                parent.AddChild(this);
            }

            Name = name;
            _startTicks = profiler.ElapsedTicks;
            StartMilliseconds = profiler.GetRoundedMilliseconds(_startTicks);
        }

        /// <summary>
        /// Initialises a new instance of the <see cref="SqlTiming"/> class. 
        /// Creates a new <c>SqlTiming</c> to profile 'command'.
        /// </summary>
        public SqlTiming(IDbCommand command, SqlExecuteType type, MiniProfiler profiler)
        {
            if (profiler == null) throw new ArgumentNullException("profiler");
            _profiler = profiler;
            
            var commandText = AddSpacesToParameters(command.CommandText);
            var parameters = GetCommandParameters(command);

            if (MiniProfiler.Settings.SqlFormatter != null)
            {
                commandText = MiniProfiler.Settings.SqlFormatter.GetFormattedSql(commandText, parameters, command);
            }

            _customTiming = profiler.CustomTiming("sql", commandText, type.ToString());
            if (_customTiming == null) throw new InvalidOperationException();
        }

        /// <summary>
        /// Initialises a new instance of the <see cref="Suppression"/> class. 
        /// Creates a new Suppression to deactive profiling while alive
        /// </summary>
        public Suppression(MiniProfiler profiler)
        {
            if (profiler == null)
            {
                throw new ArgumentNullException("profiler");
            }

            Profiler = profiler;
            if (!Profiler.IsActive)
            {
                return;
            }

            Profiler.IsActive = false;
            _wasSuppressed = true;
        }

 /// <summary>
 /// Calls <see cref="MiniProfiler.Settings.EnsureStorageStrategy"/> to save the current
 /// profiler using the current storage settings. 
 /// If <see cref="MiniProfiler.Storage"/> is set, this will be used.
 /// </summary>
 protected static void SaveProfiler(MiniProfiler current)
 {
     // because we fetch profiler results after the page loads, we have to put them somewhere in the meantime
     // If the current MiniProfiler object has a custom IStorage set in the Storage property, use it. Else use the Global Storage.
     var storage = current.Storage;
     if (storage == null)
     {
         MiniProfiler.Settings.EnsureStorageStrategy();
         storage = MiniProfiler.Settings.Storage;
     }
     storage.Save(current);
     if (current.HasUserViewed == false)
     {
         storage.SetUnviewed(current.User, current.Id);
     }
 }

        public static DbConnection GetConnection(MiniProfiler profiler = null)
        {
            using (profiler.Step("GetOpenConnection"))
            {
                DbConnection cnn = new System.Data.SQLite.SQLiteConnection(MvcApplication.ConnectionString);

                // 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 StackExchange.Profiling.Data.ProfiledDbConnection(cnn, MiniProfiler.Current);
                }

                cnn.Open();
                return cnn;
            }
        }