public static void logException(RakamHttpRequest request, Throwable e) { if (RAVEN == null) { return; } EventBuilder builder = new EventBuilder() .withSentryInterface(new ExceptionInterface(e)) .withSentryInterface(new HttpInterface(new RakamServletWrapper(request))) .withLevel(Event.Level.WARNING) .withLogger(RakamException.class.getName()); if (TAGS != null) { for (Map.Entry<String, String> entry : TAGS.entrySet()) { builder.withTag(entry.getKey(), entry.getValue()); } } if (RELEASE != null) { builder.withRelease(RELEASE); } RAVEN.sendEvent(builder.build()); }
/** * Creates a new instance from the given {@code throwable}. * * @param throwable the {@link Throwable} to build this instance from */ public ExceptionInterface(final Throwable throwable) { this(SentryException.extractExceptionQueue(throwable)); }
/** * Convert a single {@link StackTraceElement} to a {@link SentryStackTraceElement}. * * @param stackTraceElement {@link StackTraceElement} to convert. * @return {@link SentryStackTraceElement} */ public static SentryStackTraceElement fromStackTraceElement(StackTraceElement stackTraceElement) { return fromStackTraceElement(stackTraceElement, null); }
private void writeEnvironment(JsonGenerator generator, HttpInterface httpInterface) throws IOException { generator.writeStartObject(); generator.writeStringField(ENV_REMOTE_ADDR, httpInterface.getRemoteAddr()); generator.writeStringField(ENV_SERVER_NAME, httpInterface.getServerName()); generator.writeNumberField(ENV_SERVER_PORT, httpInterface.getServerPort()); generator.writeStringField(ENV_LOCAL_ADDR, httpInterface.getLocalAddr()); generator.writeStringField(ENV_LOCAL_NAME, httpInterface.getLocalName()); generator.writeNumberField(ENV_LOCAL_PORT, httpInterface.getLocalPort()); generator.writeStringField(ENV_SERVER_PROTOCOL, httpInterface.getProtocol()); generator.writeBooleanField(ENV_REQUEST_SECURE, httpInterface.isSecure()); generator.writeBooleanField(ENV_REQUEST_ASYNC, httpInterface.isAsyncStarted()); generator.writeStringField(ENV_AUTH_TYPE, httpInterface.getAuthType()); //TODO: Should that be really displayed here ? Consider the user interface? generator.writeStringField(ENV_REMOTE_USER, httpInterface.getRemoteUser()); generator.writeEndObject(); }
@Override public void writeInterface(JsonGenerator generator, HttpInterface httpInterface) throws IOException { generator.writeStartObject(); generator.writeStringField(URL, httpInterface.getRequestUrl()); generator.writeStringField(METHOD, httpInterface.getMethod()); generator.writeFieldName(DATA); writeData(generator, httpInterface.getParameters(), httpInterface.getBody()); generator.writeStringField(QUERY_STRING, httpInterface.getQueryString()); generator.writeFieldName(COOKIES); writeCookies(generator, httpInterface.getCookies()); generator.writeFieldName(HEADERS); writeHeaders(generator, httpInterface.getHeaders()); generator.writeFieldName(ENVIRONMENT); writeEnvironment(generator, httpInterface); generator.writeEndObject(); }
/** * Sets the culprit in the event based on a {@link SentryStackTraceElement}. * * @param frame stack frame during which the event was captured. * @return the current {@code EventBuilder} for chained calls. * @deprecated Culprit has been removed in favor of Transaction. */ @Deprecated public EventBuilder withCulprit(SentryStackTraceElement frame) { return withCulprit(buildCulpritString(frame.getModule(), frame.getFunction(), frame.getFileName(), frame.getLineno())); }
/** * Outputs an exception with its StackTrace on a JSon stream. * * @param generator JSonGenerator. * @param sentryException Sentry exception with its associated {@link StackTraceInterface}. * @throws IOException */ private void writeException(JsonGenerator generator, SentryException sentryException) throws IOException { generator.writeStartObject(); generator.writeStringField(TYPE_PARAMETER, sentryException.getExceptionClassName()); generator.writeStringField(VALUE_PARAMETER, sentryException.getExceptionMessage()); generator.writeStringField(MODULE_PARAMETER, sentryException.getExceptionPackageName()); generator.writeFieldName(STACKTRACE_PARAMETER); stackTraceInterfaceBinding.writeInterface(generator, sentryException.getStackTraceInterface()); generator.writeEndObject(); }
/** * Sends an exception (or throwable) to the Sentry server. * <p> * The exception will be logged at the {@link Event.Level#ERROR} level. * * @param throwable exception to send to Sentry. */ public void sendException(Throwable throwable) { EventBuilder eventBuilder = new EventBuilder().withMessage(throwable.getMessage()) .withLevel(Event.Level.ERROR) .withSentryInterface(new ExceptionInterface(throwable)); sendEvent(eventBuilder); }
private void writeDebugImages(JsonGenerator generator, DebugMetaInterface debugMetaInterface) throws IOException { generator.writeArrayFieldStart(IMAGES); for (DebugMetaInterface.DebugImage debugImage : debugMetaInterface.getDebugImages()) { generator.writeStartObject(); generator.writeStringField(UUID, debugImage.getUuid()); generator.writeStringField(TYPE, debugImage.getType()); generator.writeEndObject(); } generator.writeEndArray(); } }
@Override public void writeInterface(JsonGenerator generator, StackTraceInterface stackTraceInterface) throws IOException { generator.writeStartObject(); generator.writeArrayFieldStart(FRAMES_PARAMETER); SentryStackTraceElement[] sentryStackTrace = stackTraceInterface.getStackTrace(); int commonWithEnclosing = stackTraceInterface.getFramesCommonWithEnclosing(); for (int i = sentryStackTrace.length - 1; i >= 0; i--) { writeFrame(generator, sentryStackTrace[i], commonWithEnclosing-- > 0); } generator.writeEndArray(); generator.writeEndObject(); }
@Override public void writeInterface(JsonGenerator generator, MessageInterface messageInterface) throws IOException { generator.writeStartObject(); generator.writeStringField(MESSAGE_PARAMETER, Util.trimString(messageInterface.getMessage(), maxMessageLength)); generator.writeArrayFieldStart(PARAMS_PARAMETER); for (String parameter : messageInterface.getParameters()) { generator.writeString(parameter); } generator.writeEndArray(); if (messageInterface.getFormatted() != null) { generator.writeStringField(FORMATTED_PARAMETER, Util.trimString(messageInterface.getFormatted(), maxMessageLength)); } generator.writeEndObject(); } }
public static void logException(RakamHttpRequest request, RakamException e) { if (RAVEN == null) { return; } EventBuilder builder = new EventBuilder() .withMessage(e.getMessage()) .withSentryInterface(new HttpInterface(new RakamServletWrapper(request))) .withLevel(Event.Level.ERROR) .withLogger(RakamException.class.getName()) .withTag("status", e.getStatusCode().reasonPhrase()); if (TAGS != null) { for (Map.Entry<String, String> entry : TAGS.entrySet()) { builder.withTag(entry.getKey(), entry.getValue()); } } if (RELEASE != null) { builder.withRelease(RELEASE); } RAVEN.sendEvent(builder.build()); }
private boolean isFrameInApp(SentryStackTraceElement stackTraceElement) { // TODO: A linear search is not efficient here, a Trie could be a better solution. for (String inAppFrame : inAppFrames) { String className = stackTraceElement.getModule(); if (className.startsWith(inAppFrame) && !isBlacklistedFromInApp(className)) { return true; } } return false; }
@Override public void writeInterface(JsonGenerator generator, ExceptionInterface exceptionInterface) throws IOException { Deque<SentryException> exceptions = exceptionInterface.getExceptions(); generator.writeStartArray(); for (Iterator<SentryException> iterator = exceptions.descendingIterator(); iterator.hasNext(); ) { writeException(generator, iterator.next()); } generator.writeEndArray(); }
/** * Convert an array of {@link StackTraceElement}s to {@link SentryStackTraceElement}s. * * @param stackTraceElements Array of {@link StackTraceElement}s to convert. * @return Array of {@link SentryStackTraceElement}s. */ public static SentryStackTraceElement[] fromStackTraceElements(StackTraceElement[] stackTraceElements) { return fromStackTraceElements(stackTraceElements, null); }
private static SentryStackTraceElement fromStackTraceElement(StackTraceElement stackTraceElement, Map<String, Object> locals) { return new SentryStackTraceElement( stackTraceElement.getClassName(), stackTraceElement.getMethodName(), stackTraceElement.getFileName(), stackTraceElement.getLineNumber(), null, null, null, locals ); }
/** * Adds a {@link SentryInterface} to the event. * <p> * Checks whether or not the entry already exists, and replaces it only if {@code replace} is true. * * @param sentryInterface sentry interface to add to the event. * @param replace If true and a Sentry Interface with the same name has already been added it will be * replaced. * If false the statement will be ignored. * @return the current {@code EventBuilder} for chained calls. */ public EventBuilder withSentryInterface(SentryInterface sentryInterface, boolean replace) { if (replace || !event.getSentryInterfaces().containsKey(sentryInterface.getInterfaceName())) { event.getSentryInterfaces().put(sentryInterface.getInterfaceName(), sentryInterface); } return this; }
/** * Builds a {@link UserInterface} object from a {@link User} object. * @param user User * @return UserInterface */ private UserInterface fromUser(User user) { return new UserInterface(user.getId(), user.getUsername(), user.getIpAddress(), user.getEmail(), user.getData()); }
private void addHttpInterface(EventBuilder eventBuilder, HttpServletRequest servletRequest) { eventBuilder.withSentryInterface(new HttpInterface(servletRequest, remoteAddressResolver), false); }
/** * Creates a StackTrace for an {@link io.sentry.event.Event}. * <p> * With the help of the enclosing StackTrace, figure out which frames are in common with the parent exception * to potentially hide them later in Sentry. * * @param stackTrace StackTrace to provide to Sentry. * @param enclosingStackTrace StackTrace of the enclosing exception, to determine how many Stack frames * are in common. * @param cachedFrames Array of cached {@link Frame}s (from the Sentry agent) if available, * or null. */ public StackTraceInterface(StackTraceElement[] stackTrace, StackTraceElement[] enclosingStackTrace, Frame[] cachedFrames) { this.stackTrace = SentryStackTraceElement.fromStackTraceElements(stackTrace, cachedFrames); int m = stackTrace.length - 1; int n = enclosingStackTrace.length - 1; while (m >= 0 && n >= 0 && stackTrace[m].equals(enclosingStackTrace[n])) { m--; n--; } framesCommonWithEnclosing = stackTrace.length - 1 - m; }