public void TestRangeQueries()
        {
            var now = DateTime.UtcNow;
            var inASec = now.AddSeconds(1);
            var in2Secs = now.AddSeconds(2);
            var in3Secs = now.AddSeconds(3);
            var profiler = new MiniProfiler { Started = now, Id = Guid.NewGuid() };
            var profiler1 = new MiniProfiler { Started = inASec, Id = Guid.NewGuid() };
            var profiler2 = new MiniProfiler { Started = in2Secs, Id = Guid.NewGuid() };
            var profiler3 = new MiniProfiler { Started = in3Secs, Id = Guid.NewGuid() };

            var storage = new HttpRuntimeCacheStorage(new TimeSpan(1, 0, 0));

            storage.Save(profiler);
            storage.Save(profiler3);
            storage.Save(profiler2);
            storage.Save(profiler1);

            var guids = storage.List(100);
            Assert.AreEqual(4, guids.Count());

            guids = storage.List(1);
            Assert.AreEqual(1, guids.Count());

            guids = storage.List(2, now, in2Secs, ListResultsOrder.Decending);
            Assert.AreEqual(profiler2.Id, guids.First());
            Assert.AreEqual(profiler1.Id, guids.Skip(1).First());
            Assert.AreEqual(2, guids.Count());
        }

        public RavenTiming(RequestResultArgs request, MiniProfiler profiler)
            : base(profiler, null, null)
        {
            if (profiler == null) throw new ArgumentNullException("profiler");

            _requestUrl = request.Url;

            var commandTextBuilder = new StringBuilder();

            // Basic request information
            // HTTP GET - 200 (Cached)
            commandTextBuilder.AppendFormat("HTTP {0} - {1} ({2})\n",
                request.Method,
                request.HttpResult,
                request.Status);

            // Request URL
            commandTextBuilder.AppendFormat("{0}\n\n", FormatUrl());

            // Append query
            var query = FormatQuery();
            if (!String.IsNullOrWhiteSpace(query)) {
                commandTextBuilder.AppendFormat("{0}\n\n", query);
            }

            // Append POSTed data, if any (multi-get, PATCH, etc.)
            if (!String.IsNullOrWhiteSpace(request.PostedData))
            {
                commandTextBuilder.Append(request.PostedData);
            }

            // Set the command string to a formatted string
            CommandString = commandTextBuilder.ToString();
        }

        public void Save(MiniProfiler profiler)
        {
            var context = WcfInstanceContext.Current;
            // Do nothing if we are not being called inside a WCF method
            // Alternatively, this could throw an Exception
            if (context == null)
                return;

            context.Items[GetCacheKey(profiler.Id)] = profiler;
        }

 public void TestWeCanSaveTheSameProfilerTwice()
 {
     var profiler = new MiniProfiler("/") { Started = DateTime.UtcNow, Id = Guid.NewGuid() };
     var storage = new HttpRuntimeCacheStorage(new TimeSpan(1, 0, 0));
     storage.Save(profiler);
     storage.Save(profiler);
     var guids = storage.List(100).ToArray();
     Assert.AreEqual(profiler.Id, guids.First());
     Assert.AreEqual(1, guids.Count());
 }

        /// <summary>
        /// Stores <paramref name="profiler"/> under its <see cref="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="MiniProfiler.User"/>.
        /// </remarks>
        public void Save(MiniProfiler profiler)
        {
            // ignore browerLink URL, i.e. "/__browserLink/requestData/44067061dcd44ffcbbca1da"
            if (profiler.Name == null || profiler.Name.Contains("__browserLink"))
                return;

            // Convert the path into something that plays better with Graphite, i.e. "Home/MinSaveMs" -> "Home.MinSaveMs"
            Metrics.Timer(
                    profiler.Name.Replace("/", "."),
                    (int)profiler.DurationMilliseconds);
        }

        /// <summary>
        /// Handles <see cref="IElasticsearchResponse"/> and pushes <see cref="CustomTiming"/> to current <see cref="MiniProfiler"/> session.
        /// </summary>
        /// <param name="response"><see cref="IElasticsearchResponse"/> to be handled.</param>
        /// <param name="profiler">Current <see cref="MiniProfiler"/> session instance.</param>
		internal static void HandleResponse(IElasticsearchResponse response, MiniProfiler profiler)
		{
			if (profiler == null || profiler.Head == null || response.Metrics == null)
				return;

			profiler.Head.AddCustomTiming("elasticsearch", new CustomTiming(profiler, BuildCommandString(response))
			{
				Id = Guid.NewGuid(),
				DurationMilliseconds = response.Metrics.Requests.Sum(c => c.EllapsedMilliseconds),
				ExecuteType = response.RequestMethod,
			});
		}

    	internal static HtmlString RenderIncludes(MiniProfiler profiler, RenderPosition? position = null, bool? showTrivial = null, bool? showTimeWithChildren = null, int? maxTracesToShow = null, bool xhtml = false, bool? showControls = null)
        {
            const string format =
@"<link rel=""stylesheet"" type=""text/css"" href=""{path}mini-profiler-includes.css?v={version}""{closeXHTML}>
<script type=""text/javascript"">
    if (!window.jQuery) document.write(unescape(""%3Cscript src='{path}mini-profiler-jquery.1.6.2.js' type='text/javascript'%3E%3C/script%3E""));
    if (!window.jQuery || !window.jQuery.tmpl) document.write(unescape(""%3Cscript src='{path}mini-profiler-jquery.tmpl.beta1.js' type='text/javascript'%3E%3C/script%3E""));
</script>
<script type=""text/javascript"" src=""{path}mini-profiler-includes.js?v={version}""></script>
<script type=""text/javascript"">
    jQuery(function() {{
        MiniProfiler.init({{
            ids: {ids},
            path: '{path}',
            version: '{version}',
            renderPosition: '{position}',
            showTrivial: {showTrivial},
            showChildrenTime: {showChildren},
            maxTracesToShow: {maxTracesToShow},
            showControls: {showControls}
        }});
    }});
</script>";

            var result = "";

            if (profiler != null)
            {
                // HACK: unviewed ids are added to this list during Storage.Save, but we know we haven't see the current one yet,
                // so go ahead and add it to the end - it's usually the only id, but if there was a redirect somewhere, it'll be there, too
                MiniProfiler.Settings.EnsureStorageStrategy();
                var ids = MiniProfiler.Settings.Storage.GetUnviewedIds(profiler.User);
                ids.Add(profiler.Id);

                result = format.Format(new
                {
                    //path = VirtualPathUtility.ToAbsolute(MiniProfiler.Settings.RouteBasePath).EnsureTrailingSlash(),
					path = "",
                    version = MiniProfiler.Settings.Version,
                    ids = ids.ToJson(),
                    position = (position ?? MiniProfiler.Settings.PopupRenderPosition).ToString().ToLower(),
                    showTrivial = showTrivial ?? MiniProfiler.Settings.PopupShowTrivial ? "true" : "false",
                    showChildren = showTimeWithChildren ?? MiniProfiler.Settings.PopupShowTimeWithChildren ? "true" : "false",
                    maxTracesToShow = maxTracesToShow ?? MiniProfiler.Settings.PopupMaxTracesToShow,
                    closeXHTML = xhtml ? "/" : "",
                    showControls = showControls ?? MiniProfiler.Settings.ShowControls ? "true" : "false"
                });
            }

            return new HtmlString(result);
        }

 /// <summary>
 /// Stores <paramref name="profiler"/> under its <see cref="MiniProfiler.Id"/> in all of the <see cref="Stores"/>.
 /// </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="MiniProfiler.User"/>.
 /// </remarks>
 public void Save(MiniProfiler profiler)
 {
     if (Stores != null)
     {
         if (AllowParallelOps)
         {
             Parallel.ForEach(Stores, x => x.Save(profiler));
         }
         else
         {
             Stores.ForEach(x => x.Save(profiler));
         }
     }
 }

        public MiniProfiler GetProfiler()
        {
            // does a profiler already exist for this request?
            var profiler = HttpContext.GetProfiler();
            if (profiler != null) return profiler;

            // might want to decide here (or maybe inside the action) whether you want
            // to profile this request - for example, using an "IsSystemAdmin" flag against
            // the user, or similar; this could also all be done in action filters, but this
            // is simple and practical; just return null for most users. For our test, we'll
            // profiler only for local requests (seems reasonable)
            //if (Request.IsLocal)
            //{
                profiler = new MiniProfiler(Request.Url.OriginalString);
                HttpContext.SetProfiler(profiler);
            //}
            return profiler;
        }

        /// <summary>
        /// Creates a new SqlTiming to profile 'command'.
        /// </summary>
        public MongoTiming(string collectionName, string command, ExecuteType type, MiniProfiler profiler)
        {
            Id = Guid.NewGuid();

            CollectionName = collectionName;
            CommandString = command;
            ExecuteType = type;

            if (!MiniProfiler.Settings.ExcludeStackTraceSnippetFromSqlTimings)
                StackTraceSnippet = Helpers.StackTraceSnippet.Get();

            _profiler = profiler;
            if (_profiler != null)
            {
                _profiler.AddMongoTiming(this);
                _startTicks = _profiler.ElapsedTicks;
                StartMilliseconds = _profiler.GetRoundedMilliseconds(_startTicks);
            }
        }

        /// <summary>
        /// start the profiler.
        /// </summary>
        /// <param name="level">The profile level.</param>
        /// <returns>the mini profiler.</returns>
        public override MiniProfiler Start(ProfileLevel level, string sessionName = null)
        {
            var context = WcfInstanceContext.Current;
            if (context == null) return null;

            var operationContext = OperationContext.Current;
            if (operationContext == null) return null;

            var instanceContext = operationContext.InstanceContext;
            if (instanceContext == null) return null;

            // TODO: Include the action name here as well, and null protection
            string serviceName = instanceContext.Host.Description.Name;

            // BaseAddresses.FirstOrDefault();
            // TODO: Ignored paths - currently solely based on servicename

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

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

            var result = new MiniProfiler(sessionName ?? GetProfilerName(operationContext, instanceContext), level);

            SetCurrentProfiler(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 ?? new EmptyUserProvider()).GetUser(/*context.Request*/);

            SetProfilerActive(result);

            return result;
        }

        /// <summary>
        /// Giving freshly selected collections, this method puts them in the correct
        /// hierarchy under the 'result' MiniProfiler.
        /// </summary>
        protected void MapTimings(MiniProfiler result, List<Timing> timings, List<SqlTiming> sqlTimings, List<SqlTimingParameter> sqlParameters)
        {
            var stack = new Stack<Timing>();

            for (int i = 0; i < timings.Count; i++)
            {
                var cur = timings[i];
                foreach (var sqlTiming in sqlTimings)
                {
                    if (sqlTiming.ParentTimingId == cur.Id)
                    {
                        cur.AddSqlTiming(sqlTiming);

                        var parameters = sqlParameters.Where(p => p.ParentSqlTimingId == sqlTiming.Id);
                        if (parameters.Count() > 0)
                        {
                            sqlTiming.Parameters = parameters.ToList();
                        }
                    }
                }

                if (stack.Count > 0)
                {
                    Timing head;
                    while ((head = stack.Peek()).Id != cur.ParentTimingId)
                    {
                        stack.Pop();
                    }

                    head.AddChild(cur);
                }
                stack.Push(cur);
            }

            // TODO: .Root does all the above work again, but it's used after [DataContract] deserialization; refactor it out somehow
            result.Root = timings.First();
        }

        /// <summary>
        /// results full page.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="profiler">The profiler.</param>
        /// <returns>a string containing the results page</returns>
        private static string ResultsFullPage(HttpContext context, MiniProfiler profiler)
        {
            context.Response.ContentType = "text/html";

            var template = GetResource("share.html");
            return template.Format(new
            {
                name = profiler.Name,
                duration = profiler.DurationMilliseconds.ToString(CultureInfo.InvariantCulture),
                path = VirtualPathUtility.ToAbsolute(MiniProfiler.Settings.RouteBasePath).EnsureTrailingSlash(),
                json = MiniProfiler.ToJson(profiler),
                includes = RenderIncludes(profiler),
                version = MiniProfiler.Settings.Version
            });
        }

        /// <summary>
        /// Renders script tag found in "include.partial.html" - this is shared with all other language implementations, so if you change it, you MUST
        /// provide changes for those other implementations, e.g. ruby.
        /// </summary>
        internal static HtmlString RenderIncludes(
            MiniProfiler profiler,
            RenderPosition? position = null,
            bool? showTrivial = null,
            bool? showTimeWithChildren = null,
            int? maxTracesToShow = null,
            bool? showControls = null,
            bool? startHidden = null)
        {
            if (profiler == null) return new HtmlString("");

            MiniProfiler.Settings.EnsureStorageStrategy();
            var authorized = MiniProfiler.Settings.Results_Authorize == null || MiniProfiler.Settings.Results_Authorize(HttpContext.Current.Request);

            // unviewed ids are added to this list during Storage.Save, but we know we haven't see the current one yet, so go ahead and add it to the end
            var ids = authorized ? MiniProfiler.Settings.Storage.GetUnviewedIds(profiler.User) : new List<Guid>();
            ids.Add(profiler.Id);

            var format = GetResource("include.partial.html");
            var result = format.Format(new
            {
                path = VirtualPathUtility.ToAbsolute(MiniProfiler.Settings.RouteBasePath).EnsureTrailingSlash(),
                version = MiniProfiler.Settings.Version,
                ids = string.Join(",", ids.Select(guid => guid.ToString())),
                position = (position ?? MiniProfiler.Settings.PopupRenderPosition).ToString().ToLower(),
                showTrivial = (showTrivial ?? MiniProfiler.Settings.PopupShowTrivial).ToJs(),
                showChildren = (showTimeWithChildren ?? MiniProfiler.Settings.PopupShowTimeWithChildren).ToJs(),
                maxTracesToShow = maxTracesToShow ?? MiniProfiler.Settings.PopupMaxTracesToShow,
                showControls = (showControls ?? MiniProfiler.Settings.ShowControls).ToJs(),
                currentId = profiler.Id,
                authorized = authorized.ToJs(),
                toggleShortcut = MiniProfiler.Settings.PopupToggleKeyboardShortcut,
                startHidden = (startHidden ?? MiniProfiler.Settings.PopupStartHidden).ToJs()
            });

            return new HtmlString(result);
        }

        /// <summary>
        /// set the current profiler.
        /// </summary>
        /// <param name="profiler">The profiler.</param>
        private void SetCurrentProfiler(MiniProfiler profiler)
        {
            var context = WcfInstanceContext.Current;
            if (context == null) return;

            context.Items[WcfCacheKey] = profiler;
        }

        /// <summary>
        /// Saves parameter Timing to the sqltimingparams collection.
        /// </summary>
        private void SaveSqlTimingParameters(MiniProfiler profiler, SqlTiming s)
        {
            foreach (var p in s.Parameters)
            {
                var sqltimingParamPoco = new SqlTimingParameterPoco
                {
                    MiniProfilerId = profiler.Id.ToString(),
                    ParentSqlTimingId = s.Id.ToString(),
                    Name = Truncate(p.Name, 150),
                    DbType = Truncate(p.DbType, 50),
                    Size = p.Size,
                    Value = p.Value
                };

                SqlTimingParams.Insert(sqltimingParamPoco);
            }
        }

        private void SaveClientTiming(MiniProfiler profiler)
        {
            if (profiler.ClientTimings == null || profiler.ClientTimings.Timings == null || profiler.ClientTimings.Timings.Count == 0) return;

            foreach (var ct in profiler.ClientTimings.Timings)
            {
                ClientTimings.Save(new ClientTimingPoco
                {
                    Id = profiler.Id.ToString(),
                    Name = ct.Name,
                    Start = (double)ct.Start,
                    Duration = (double)ct.Duration
                });
            }
        }

        /// <summary>
        /// Loads the MiniProfiler identifed by 'id' from the database.
        /// </summary>
        public override MiniProfiler Load(Guid id)
        {
            var query = Query.EQ("_id", id.ToString());

            var profilerPoco = Profilers.FindOne(query);

            if (profilerPoco != null)
            {
                var profiler = new MiniProfiler
                {
                    Id = Guid.Parse(profilerPoco.Id),
                    Name = profilerPoco.Name,
                    Started = profilerPoco.Started,
                    MachineName = profilerPoco.MachineName,
                    User = profilerPoco.User,
                    Level = profilerPoco.Level,
                    HasUserViewed = profilerPoco.HasUserViewed
                };

                if (profiler != null)  //This is very similar to the Load logic in the SqlServerStorage.
                    //Perhaps another abstraction layer(or moving some logic into the Base) which both Mongo and Sql inherit from would eliminate somewhat repetitive code.
                {
                    var timings = LoadTimings(profiler.Id);
                    var sqlTimings = LoadSqlTimings(profiler.Id);
                    var mongoTimings = LoadMongoTimings(profiler.Id);
                    var sqlParams = LoadSqlTimingParameters(profiler.Id);
                    var clientTimingList = LoadClientTimings(profiler.Id);
                    ClientTimings clientTimings = null;
                    if (clientTimingList.Count > 0)
                    {
                        clientTimings = new ClientTimings();
                        clientTimings.Timings = clientTimingList;
                    }

                    MapTimings(profiler, timings, sqlTimings, sqlParams, clientTimings, mongoTimings);
                }

                profiler.OnDeserialized();

                return profiler;
            }

            return null;
        }

 /// <summary>
 /// The assert mini profiler exists.
 /// </summary>
 /// <param name="miniProfiler">The mini Profiler.</param>
 private void AssertMiniProfilerExists(MiniProfiler miniProfiler)
 {
     Assert.That(_conn.Query<int>("select count(*) from MiniProfilers where Id = @Id", new { miniProfiler.Id }).Single() == 1);
 }

 /// <summary>
 /// set the JSON results and the content type.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="profiler">The profiler.</param>
 /// <returns>a string containing the JSON results.</returns>
 private static string ResultsJson(HttpContext context, MiniProfiler profiler)
 {
     context.Response.ContentType = "application/json";
     return MiniProfiler.ToJson(profiler);
 }