Our docs contain a Common Questions section as needed at the bottom of specific topics. We’ve captured items here that don’t fit in the other topics.

If you don’t see an answer to your question here, check our previously reported issues.

Does Glimpse modify incoming requests or outgoing responses?

Glimpse adds the following headers to outgoing responses:

  • X-Glimpse-ContextId: A unique ID used to correlate Glimpse-captured data with the request.

Glimpse also adds the following cookies to outgoing responses:

  • .Glimpse.ContextId: A unique ID used to correlate Glimpse-captured data with the request.
  • .Glimpse.Session: A unique ID used to correlate Glimpse activity to a single browser session.

For outgoing HTML responses, Glimpse will inject two <script> tags, one for the Glimpse browser agent with which to instrument and report activity in the browser and the other for the Glimpse heads up display (HUD) in the lower-right corner of the page.

How long will Glimpse keep request data?

By default, Glimpse keeps request data in an in-process, in-memory store which means that Glimpse keeps request data only while your application is running. When running, Glimpse will keep a maximum of 500 requests at any given time, with data for older requests being dropped in favor of new requests.

Why does Glimpse not display timing or resource loading data for requests made by some browsers?

Some browsers (e.g. Safari) do not support the W3C User Timing specification for performance.mark() and performance.measure() and so the Glimpse browser agent cannot capture that activity. Likewise, if the browser does not support the W3C Resource Timing specification, Glimpse cannot capture resource loading and timing information.

What endpoints does Glimpse create in addition to any created by my application?

Glimpse intercepts requests made to the endpoints created by your application, in order to capture activity performed by the application. Glimpse also creates several endpoints used to store and retrieve that activity, as well as to serve the Glimpse client. By default, these endpoints are exposed at the relative /glimpse URL.

Some of those endpoints you might notice while using Glimpse are:

  • /glimpse/agent: Serves the Glimpse browser agent.
  • /glimpse/client: Serves the Glimpse client.
  • /glimpse/context: Returns messages associated with a given request.
  • /glimpse/hud: Serves the Glimpse heads up display (HUD).
  • /glimpse/message-ingress: Used by Glimpse agents to store activity related to a request.
  • /glimpse/message-stream: Used by the Glimpse client to receive real-time updates of request activity.
  • /glimpse/metadata: Returns information about each endpoint exposed by Glimpse.

How do I disable telemetry?

Glimpse collects anonymized telemetry data to provide the development team insight into the product’s usage and quality level. This data helps us make informed decisions and build the best possible product, one we hope you’ll get a lot of benefit from. We take privacy seriously. Please see our privacy policy for more information. If you would like to disable telemetry and error reporting, you can launch your app with the telemetry.enabled flag set to false. See the configuration section for more details on how to specify Glimpse configuration options.

Why can’t I see the HUD?

If you are only serving static resources, the Glimpse HUD and browser agent (which is responsible for capturing timing and performance data) will not be injected into web pages. This is known issue. We rely on express.Response.send() to do the injection of the browser agent and HUD script; if that method isn’t called (as express.static() just delegates to static()), neither the HUD nor the browser agent will get injected. If you wish, you can inject the scripts yourself manually.

You can always launch the Glimpse client at <site>/glimpse/client, where <site> is your site’s base URL (e.g., http://localhost:3000/glimpse/client).

Why do I see [anonymous] reported by Glimpse?

When Glimpse instruments your application, it does its best to identify and report the actual names of the components involved (e.g. application middleware shown in the Timeline and Requests tabs). JavaScript, however, allows the definition of unnamed (i.e. anonymous) functions. In those cases, Glimpse may not have any other information with which to label that component and so will report [anonymous]. You can use the call stack information (i.e. file and line number) reported by Glimpse to help identify a given component.

Alternatively, you can simply name your functions. For a “traditional” function you can just add the name inline. For a “fat-arrow” (=>) function, it’s admittedly more complicated. Some Javascript engines (e.g. in later versions of Node.js) will actually give a fat-arrow function the name of the first field to which it’s assigned.

// Glimpse will report `[anonymous]`.
app.use(function (req, res, next) {

// Glimpse will report `namedFunction`.
app.use(function namedFunction(req, res, next) {

// Glimpse will report `[anonymous]`.
app.use((req, res, next) => {

// Glimpse may report `assignedFatArrow` or `[anonymous]`, 
// depending on the Javascript engine implementation and version.
var assignedFatArrow = (req, res, next) => {

How can I see request data from multiple applications?

By default, Glimpse will run in a configuration that supports diagnostics of a single Node.js process. If you want to see diagnostics from multiple applications, you can configure your applications as described in the configuration instructions here.

An experiment by Microsoft