Documentation - Searching error groups

Error Search

Raygun search allows you to view error groups and instances that match the keyword queries you enter. The search box is available below the application switcher in the top-left corner of the application dashboard.

By default search queries with multiple keywords are ANDed together, so only errors that match all keywords will be returned.

Fuzzy queries

Raygun search supports partial matching (e.g for when searching for affected users), so to locate a user 'John Smith' with the email '', you could search for, person, john or smith and other such combinations.

camelCase and PascalCase strings (e.g class names) are also supported - so if you have a type like myAwesomeCustomException, it can be located by entering any combination of the keywords myawesomecustom or exception. This is not currently case-insensitive, so you can also query for it with myAwesomeCustomException, but not myawesomecustomexception.

You are able to search with terms that contain a colon if they are not listed in the reserved fields above. This includes the double-colon scope resolution operator ('::') as used in some languages.

You can also search for method/function calls that include '()' - for instance the query contains() will return errors that have 'Contains()' in their stack trace.

Well-known field queries

Many important fields are indexed, including the message, class name, stack trace, and more. By default, all of these are searched when submitting a query. If you want to target a particular field, you can add one of these prefixes to the query:

  • message
  • version
  • url
  • querystring
  • host
  • impacteduser
  • exceptiontype
  • stacktrace (class names and method names only)
  • innererror
  • customtags
  • customdata
  • machinename
  • browser
  • operatingsystem
  • device
  • architecture
  • devicemanufacturer
  • model
  • errorgroupid

For instance, to search only through the custom data of your errors, enter customdata: foo.

Browser searching

Errors for certain browsers can be searched for by providing a search query such as browser: chrome or browser: ie. You can also specify the version, for instance browser: ie8. This provides an alternative to the browser predicate in the filter UI.

Query by Error Group ID

As above, you can search for a particular error group by ID by submitting the query errorgroupid: {{id}}. The error group ID is located after the /errors/ segement in the REST URL path for an error group. For instance, /crashreporting/{{appid}}/errors/{{errorgroupid}}.

Exact queries

Wrap a query in double-quotes, e.g. "foo-bar", which will match raw message, separated only by whitespace. For instance, without double-quotes, exceptions will be returned which have the tokens 'foo' and 'bar', but when wrapped in quotes only exceptions with messages that contain the string 'foo-bar' will be included.


The search engine supports the standard wildcard characters * and ?. When included in your search query string, these will match from all characters preceding it, to any after it (or all, if it is the final character). This is supported for both exact and non-exact queries (ones that aren't wrapped in double-quotes), but is particularly useful for the latter for precise matching.

Wildcard querying allows you to match part of a substring, by matching on any errors that have a particular field with a value that starts with that string exactly. For instance, the query "#ff*" will return any errors that include both #ffffff and #ff0000, but not #000000. The first character in the query string should not be one of the two wildcard characters above - it must a regular character (otherwise it is ignored).

Boolean queries

Raygun Search supports common boolean logic with your supplied terms:

  • AND - matches error groups where both terms exists. For instance 'foo AND bar' will return error groups that contain both 'foo' and 'bar'.
  • OR - matches error groups where either term exists. For instance 'foo OR bar' will return all error groups that contain either 'foo' or  'bar'.
  • NOT - matches error groups that don't contain the next term. For instance 'NOT foo' will return all error groups that don't contain 'foo'
  • Sub-query grouping with brackets - specify precise boolean queries with curvy brackets. For example '(foo OR bar) AND baz' will return all error groups that contain 'baz' along with 'foo' or 'bar',

Please note that all boolean terms must be written in UPPER CASE, terms in lower case will not act as a boolean operator.

User Search

Specific users can be searched on the "Users" page. Simply enter provided user's details into the search box. The search is performed on the firstNamefullNameemailidentifier and uuid field's by default. Results are ordered by the number of attributes matching the search terms.

Documentation missing?

If we don't have documentation about your desired topic, send us a message and we'll create it for you.