HTTP Supervisor
HTTP Supervisor is a simple library (also available as chrome addon) that helps to audit HTTP requests and identify the requests that exceeds the set quota. It also helps to group, sort, search and export requests.
The tool renders a simple UI that provides controls to capture the requests and print to console in a better readable format. It also provides a global object for you to work with requests from developer console.
Last but not least it also provides visualization support using the chart.js library.
Demo
Screenshots
Enable / Disable In Any Page Using Addon
UI with controls
Console Output
Data Visualization
Features
- Auditing Requests By Setting Quota
- Searching Requests Based On Different Criteria
- Nested Grouping
- Multi Sorting
- Printing Requests
- Exporting Requests As CSV
- Exporting / Importing Configuration
- Visualization Through Charts
- Watching Requests
- Copying Requests
Install
Currently it’s available in npm
.
npm i http-supervisor --save-dev
I’ve also created a chrome addon and it’s currently in pending review state meanwhile you can locally install the “addon” folder in the repo to chrome extensions which is quite easy :)
The library exports a single object called http
through which you can control the audit and manage the requests.
Initializing Supervisor
The init
method helps to configure and initialize the tool. You should call this method to start the audit and it can be called only once.
http.init({
include: ['https://my.api.com'],
alertOnError: true
})
You can pass a bunch of parameters to the init
method to configure the tool which you can see at the API section.
Starting Audit
Calling the init
method start the audit. If you stopped it for some reason and you can restart it by calling the start
method.
http.start();
Stopping Audit
You can temporarily stop auditing by calling stop
method.
http.stop();
Getting Requests
The library provides a method called query
that gives you all the captured requests in a custom collection.
const requests = http.query();
The output of the query
method is a custom collection extended from array that helps you to search, group and sort requests.
You can get a single request by passing the id
to the get
method.
const request = http.get(1);
The output request is of type HttpRequestInfo
.
Sorting Requests
You can multi-sort the requests.
const requests = http.sort({ field: 'method', dir: 'asc' }, { field: 'responseSize', dir: 'desc' });
Grouping Requests
You can group and sub-group requests.
const requests = http.group('part', 'method');
There are also methods available that helps to group and sort in the same call.
Searching Requests
You can also search requests on different fields passing different operators.
const requests = http.query('/token');
const requests = http.query('GET');
const requests = http.query('responseSize', '>', '1 kb');
const requests = http.query({ field: 'responseSize', operator: '>', value: '1 kb' });
Printing Requests
Calling the print
method displays the requests in console using the default group and sort parameters.
http.print()
The method accepts different kind of parameters to search, group and sort the requests before printing. You can also pass a request or collection to this method and that’ll be printed.
Printing a request passing id
Each http request is associated with a unique id. You can print the details of a single request by just passing the id.
http.print(id);
Printing requests of a particular http method
You can print requests belongs to a particular http method (GET, POST etc.) by passing the http method name.
http.print('GET');
Printing requests matches an url
By passing an url (relative/absolute) the methods prints all the requests belongs to it.
http.print('/api/v3');
You can also pass glob patterns.
http.print('https://api.domain.com/v3/*');
Search, group, sort and then print requests
The method also accepts search, group and sort parameters that’ll be applied over the requests before printing them.
http.print(
[{field: 'method', operator: '=', value: 'GET'}], // search
['url', 'method'], // group
[{ field: 'responseSize', dir: 'desc' }] //sort
);
If you want to only sort you can pass null
to search and group parameters.
Printing any request or collection
You can pass any request or collection to the print method and it’ll print it.
http.print(request);
http.print(collection);
Exporting Requests
You can export requests as CSV/JSON by calling the export
method.
http.export(); // export as CSV
http.export('json') // export as JSON
Exporting / Importing Configuration
You can export the configuration of supervisor by passing true
as the last argument.
http.export('json', true);
You can import a saved configuration by calling the import
method.
http.import();
Visualizing Requests
The library provides methods to visualize data through charts. The timeChart
method prints the time taken by each request through a bar chart. There are other methods to visualize different information please check the API section.
http.timeChart()
API
HttpSupervisor
Properties
busy
Returns true
if the supervisor is busy audit.
status
Returns the current status of the supervisor. It could be one of these values: “busy”, “idle”, “not-ready” or “retired”.
totalRequests
Returns the total count of requests.
include
Gets/sets the url patters to monitor. As default monitors all requests.
exclude
Gets/sets the url patters to ignore.
renderUI
Returns true
if ui is required. As default the value is true
.
displayUI
Shows/hides UI if renderUI
is set as true
.
silent
Gets/sets whether to display any messages to console or not. As default the value is false
.
traceEachRequest
Gets/sets whether each request need to be printed in console. As default the value is false
.
alertOnError
Gets/sets whether we need to display the request on error in console. As default the value is true
.
alertOnExceedQuota
Gets/sets whether to display requests exceeded quota in console. As default the value is true
.
alertOnRequestStart
Gets/sets whether to alert the request info in console on request starting stage. As default the value is false
.
quota
Gets/sets the quota. It’s an object that takes three parameters maxPayloadSize
, maxResponseSize
and maxDuration
. The default values are 10 kb, 10 kb and 1 second respectively.
groupBy
Gets/sets the group parameters that is used while displaying requests in console on calling print
method. As default the requests are grouped by part
and method
(properties of HttpRequestInfo
class; you'll see all the members of the class in API section).
sortBy
Gets/sets the sort parameters that is used while displaying requests in console. As default the requests are sorted by id
in ascending order.
usePerformance
Gets/sets whether to use performance.getEntriesByType
API for calculating more precise duration and resource size. Using this feature will add a new query parameter "hs_rid" in the url. As default the value is true
.
monkeyPatchFetch
Gets/sets whether to monkey patch window.fetch
method to capture fetch requests. As default the value is true
.
loadChart
Returns true
if visualization is enabled. As default the value is true
.
keyboardEvents
Gets/sets whether to control the supervisor through keyboard events. As default the value is true
.
persistConfig
Gets/sets whether to persist configuration in browser storage. As default the value is true
.
lockConsole
Gets/sets whether to lock developer console. Doing this will block all other messages to console by other scripts until the lock is released. As default the value is false
.
onGoingCallsCount
Returns the numbers of calls in progress.
HttpSupervisor
Methods
init(config: object, loadConfigFromStore = true)
Configures the supervisor. You can pass the following parameters to the config
object:
include
(Array) - Array of url glob patterns to monitor.exclude
(Array) - Array of url glob patterns to ignore.renderUI
(boolean) - Passingtrue
will render UI.traceEachRequest
(boolean) - Passingtrue
will print each request.alertOnError
(boolean) - Passingtrue
will print error requests.alertOnExceedQuota
(boolean) - Passingtrue
will print requests that exceeds quota.alertOnRequestStart
(boolean) - True to alert on request start.quota
(object) - Request Quota. It's an object that can have three properties:maxPayloadSize
,maxResponseSize
andmaxDuration
. Any request that exceeds any of this value is assumed to be exceeded quota.groupBy
(Array) - Grouping parameters used in displaying requests.sortBy
(Array<{field: string, dir: 'asc' | 'desc'}>) - Sorting parameters used in displaying requests.usePerformance
(boolean) - True to use performance.getEntriesByType for accurate duration and payload info.monkeyPatchFetch
(boolean) - True to monkey patch fetch requests.loadChart
(boolean) - True to use chart.js library for data visualization.keyboardEvents
(boolean) - True to use keyboard events for operating control panel.persistConfig
(boolean) - True to persist config in local storage.watches
(Array<{field: string, operator: string, value: any}>) - Collection of watches.lockConsole
(boolean) - True to lock developer console so except supervisor other scripts can't print messages in console.
Passing true
for loadConfigFromStore
loads the config from local storage.
Example
http.init({
include: ['http://api.domain.com/v1/*'],
exclude: ['*/token'],
traceEachRequest: true,
groupBy: ['part', 'method'],
sortBy: [{ field: 'payloadSize', dir: 'asc' }]
});
start()
Starts network monitoring.
stop()
Stops network monitoring.
clear()
Clears the requests log.
on(eventName: string, handler: function)
Subscribes to the passed event. Below are the events emitted.
ready
- Fired when the supervisor is ready.start
- Fired when the supervisor is started.stop
- Fired when the supervisor is stopped.clear
- Fired when the captured requests log is cleared.retire
- Fired when the supervisor is destroyed.request-start
- Fired when a HTTP request is started.request-end
- Fired when a HTTP request is finished.request-error
- Fired when a HTTP request errors out.exceeds-quota
- Fired when a HTTP request exceeds quota.config-change
- Fired when the configuration of the supervisor is changed.
off(eventName: string, handler: function)
Un-subscribes from the passed event.
retire(clearStore = false)
Retires the supervisor. Passing clearStore
as true
will clear the stored configuration from browser storage.
get(arg)
Returns request for the passed id or url.
const firstRequest = http.get(1);
const tokenRequest = http.get('/token');
Returns object of type HttpRequestInfo
. The HttpRequestInfo
class is the one that captures all the information related to a single request.
Below are the properties of this class.
id
(number) - Unique id of the request.url
(string) - The url of the request.domain
(string) - The domain of the request.path
(string) - The path from the url.part
(string) - The last part of the path from url with search query.method
(GET | POST | PUT | DELETE) - HTTP request method.payload
(object) - The request payload.payloadSize
(number) - The request payload size.timeStart
(number) - The request start time.timeEnd
(number) - The request end time.duration
(number) - Time taken by the request.response
(*) - The response of the request.responseSize
(number) - The response size.responseStatus
(number) - The response status.error
(boolean) - True if the request error-ed out.errorDescription
(*) - The error description same as the response.exceedsQuota
(boolean) - True if the request exceeds quota.initiatorType
(xhr | fetch) - Whether the ajax call is triggered by xhr or fetch.payloadByPerformance
(number) - True if the payload size is determined using performance api.requestHeaders
(Map) - Request Headers.responseHeaders
(Map) - Response Headers.pending
(boolean) - True if the request is pending.
Below are the constructor and methods of this class.
constructor(id, url, method, payload)
fire(type = 'xhr', reqOptions = {})
- Issues AJAX request using the property values.
first()
Returns the first request from the log.
last()
Returns the last request from the log.
failed()
Returns the failed requests.
exceeded()
Returns the requests that exceeded the quota.
lastFailed()
Returns the last failed request.
maxSizeRequest()
Returns the request that has maximum response size.
maxDurationRequest()
Returns the request that took maximum time to complete.
group(...args)
Groups the requests based on the passed fields.
Examples:
const groupedByMethod = http.group('method');
const groupedByUrlMethodPayload = http.group('url', 'method', 'payload');
The output of the above method is of type Collection
which is a custom class that extends Array and had methods to do multi-sorting, nested grouping and searching.
sort(...args)
Sorts the requests based on the passed arguments.
Examples:
const sortedByResponseSize = http.sort('responseSize', 'asc');
const sortedByResponseSize = http.sort({ field: 'responseSize', dir: 'asc' });
const multiSorted = http.sort([{ field: 'id', dir: 'asc' }, { field: 'responseSize', dir: 'asc' }]);
query()
Returns the captured requests performing sorting, grouping as well.
Calling the query
method without passing any argument returns all the requests.
const allRequests = http.query();
Passing a string as input returns the requests that contains/matches the url.
const requestsContainsTokenInUrl = http.query('/token');
const requestMatchesApi = http.query('*/api/*');
If the string matches the HTTP request method then it returns all the requests of that type.
const getRequests = http.query('GET');
Passing search query.
const requests = http.query('method', '=', 'GET');
The above method returns all the requests of method “GET”.
Passing multiple search conditions.
const maxSizeGetRequests = http.query([{ field: 'method', operator: '=', value: 'GET' }, { field: 'responseSize', operator: '>', value: '10 kb' }];
The different operators you can utilize are: “=”, “!=”, “>”, “<”, “>=”, “<=”, “~” (starts with), “^” (ends with), “contains”, “!contains”, “matches” and “!matches”.
totalPayload()
Returns the total payload size summing all requests.
totalSize()
Returns the total response size summing all requests.
maxPayload()
Returns the max payload size of the requests.
maxResponse()
Returns the max response size of the requests.
maxDuration()
Returns the max duration.
print(...args)
Prints the requests after searching, grouping and sorting. We can also pass a request or collection to the method and it prints it.
Printing a request by passing the id.
http.print(1);
Printing all the POST requests.
http.print('POST');
Printing all the request that matches “token”.
http.print('*/token');
Printing all the requests with the default groupBy
and sortBy
properties.
http.print();
Printing a subset fields of all the requests.
http.print({ displayFields: ['url', 'method', 'response'] });
Printing requests after searching, grouping and sorting.
http.print(
[{field: 'method', operator: '=', value: 'GET'}], // search
['url', 'method'], // group
[{ field: 'responseSize', dir: 'desc' }] //sort
);
printFailed(displayFields?)
Prints failed requests. Passing an array of fields as second parameter will only display those fields in the console.
printExceeded(displayFields)
Prints requests exceeds quota.
printLastFailed()
Prints the last failed request.
printLast()
Prints the last request.
printMaxSizeRequest()
Prints the request that has maximum size.
printMaxDurationRequest()
Prints the request that took maximum time.
sizeChart()
Displays the bar chart of responsive size.
timeChart()
Displays the bar chart of responsive size.
sizeTimeChart()
Displays bubble chart for response size and time.
sizeDistributionChart()
Displays the response size distribution.
import()
Calling this method will opens the system file dialog and selecting a persisted configuration file will imports the configuration to the supervisor.
export(...args)
Export requests as a CSV / JSON file.
http.export(); // Export as CSV
http.export('json'); // Export as JSON
http.export('json', true); // Export the configuration as JSON
http.export(collection); // Export the passed collection as CSV
http.export(collection, 'json'); // Export the passed collection as JSON
watchOn(...args)
Alert on console the request that matches the passed arguments.
Example:
http.watch('*/token'); // watch any request that is fired for url matching "/token".
http.watch({ field: 'responseSize', operator: '>', value: '10 kb' }); // watch any request that exceeds 10 kb.
removeWatch(watchId)
Remove the watch for the passed id.
clearWatches()
Clear all watches.
clearStore()
Removes the stored config from session storage.
fire(id, type = InitiatorType.XHR, reqOptions = {})
Re-issues ajax request for the passed http request.
record()
Creates a new session.
end()
Ends the current session.
getSession(id)
Returns session for the passed id.
removeSession(id)
Removes the passes session.
clearSessions()
Clear all sessions.
copy(id, content = 'response')
Copies the response, payload or the complete request to clipboard.
clearCopy()
Clears the copied content.
Contact
http://prideparrot.com/contact
License
MIT