public void notify(String subject, Map<String, String> extraData) { if (!raven.isPresent()) { return; } final StackTraceElement[] currentThreadStackTrace = Thread.currentThread().getStackTrace(); final EventBuilder eventBuilder = new EventBuilder() .withMessage(getPrefix() + subject) .withLevel(Event.Level.ERROR) .withLogger(getCallingClassName(currentThreadStackTrace)); if (extraData != null && !extraData.isEmpty()) { for (Map.Entry<String, String> entry : extraData.entrySet()) { eventBuilder.withExtra(entry.getKey(), entry.getValue()); } } sendEvent(raven.get(), eventBuilder); } }
private void sendEvent(Raven raven, final EventBuilder eventBuilder) { raven.runBuilderHelpers(eventBuilder); raven.sendEvent(eventBuilder.build()); }
public void notify(String message, Throwable t, Map<String, String> extraData) { if (!raven.isPresent()) { return; } final StackTraceElement[] currentThreadStackTrace = Thread.currentThread().getStackTrace(); final EventBuilder eventBuilder = new EventBuilder() .withCulprit(getPrefix() + message) .withMessage(Strings.nullToEmpty(message)) .withLevel(Event.Level.ERROR) .withLogger(getCallingClassName(currentThreadStackTrace)) .withSentryInterface(new ExceptionInterface(t)); if (extraData != null && !extraData.isEmpty()) { for (Map.Entry<String, String> entry : extraData.entrySet()) { eventBuilder.addExtra(entry.getKey(), entry.getValue()); } } sendEvent(raven.get(), eventBuilder); }
EventBuilder eventBuilder = new EventBuilder() .withLevel(getLevel(record.getLevel())) .withTimestamp(new Date(record.getMillis())) .withLogger(record.getLoggerName()); eventBuilder.withSentryInterface(new MessageInterface(message, parameters)); message = MessageFormat.format(message, record.getParameters()); eventBuilder.withMessage(message); eventBuilder.withSentryInterface(new ExceptionInterface(throwable)); eventBuilder.withCulprit(fakeFrame); } else { eventBuilder.withCulprit(record.getLoggerName()); for (Map.Entry<String, String> mdcEntry : mdc.entrySet()) { if (extraTags.contains(mdcEntry.getKey())) { eventBuilder.withTag(mdcEntry.getKey(), mdcEntry.getValue()); } else { eventBuilder.withExtra(mdcEntry.getKey(), mdcEntry.getValue()); eventBuilder.withTag(tagEntry.getKey(), tagEntry.getValue()); eventBuilder.withExtra(THREAD_ID, record.getThreadID()); return eventBuilder.build();
/** * Sends a message to the Sentry server. * <p> * The message will be logged at the {@link Event.Level#INFO} level. * * @param message message to send to Sentry. */ public void sendMessage(String message) { EventBuilder eventBuilder = new EventBuilder().withMessage(message) .withLevel(Event.Level.INFO); runBuilderHelpers(eventBuilder); sendEvent(eventBuilder.build()); }
/** * Adds a {@link SentryInterface} to the event. * <p> * If a {@code SentryInterface} with the same interface name has already been added, the new one will replace * the old one. * * @param sentryInterface sentry interface to add to the event. * @return the current {@code EventBuilder} for chained calls. */ public EventBuilder withSentryInterface(SentryInterface sentryInterface) { return withSentryInterface(sentryInterface, true); }
/** * Sets the culprit in the event based on a {@link StackTraceElement}. * * @param frame stack frame during which the event was captured. * @return the current {@code EventBuilder} for chained calls. * @deprecated Use {@link #withCulprit(StackTraceElement)} instead. */ @Deprecated public EventBuilder setCulprit(StackTraceElement frame) { return withCulprit(frame); }
/** * Sets the logger in the event. * * @param logger logger of the event. * @return the current {@code EventBuilder} for chained calls. * @deprecated Use {@link #withLogger(String)} instead. */ @Deprecated public EventBuilder setLogger(String logger) { return withLogger(logger); }
/** * Sets the message in the event. * * @param message message of the event. * @return the current {@code EventBuilder} for chained calls. * @deprecated Use {@link #withMessage(String)} instead. */ @Deprecated public EventBuilder setMessage(String message) { return withMessage(message); }
/** * Adds an extra property to the event. * * @param extraName name of the extra property. * @param extraValue value of the extra property. * @return the current {@code EventBuilder} for chained calls. * @deprecated use {@link #withExtra(String, Object)} instead. */ @Deprecated public EventBuilder addExtra(String extraName, Object extraValue) { return withExtra(extraName, extraValue); }
/** * Sets the log level in the event. * * @param level log level of the event. * @return the current {@code EventBuilder} for chained calls. * @deprecated Use {@link #withLevel(Event.Level)} instead. */ @Deprecated public EventBuilder setLevel(Event.Level level) { return withLevel(level); }
/** * Sets the timestamp in the event. * * @param timestamp timestamp of the event. * @return the current {@code EventBuilder} for chained calls. * @deprecated Use {@link #withTimestamp(Date)} instead. */ @Deprecated public EventBuilder setTimestamp(Date timestamp) { return withTimestamp(timestamp); }
/** * Adds a tag to an event. * <p> * This allows to set a tag value in different contexts. * * @param tagKey name of the tag. * @param tagValue value of the tag. * @return the current {@code EventBuilder} for chained calls. * @deprecated use {@link #withTag(String, String)} instead. */ @Deprecated public EventBuilder addTag(String tagKey, String tagValue) { return withTag(tagKey, tagValue); }
EventBuilder eventBuilder = new EventBuilder() .withTimestamp(new Date(iLoggingEvent.getTimeStamp())) .withMessage(iLoggingEvent.getFormattedMessage()) .withLogger(iLoggingEvent.getLoggerName()) .withLevel(formatLevel(iLoggingEvent.getLevel())) .withExtra(THREAD_NAME, iLoggingEvent.getThreadName()); eventBuilder.withSentryInterface(new MessageInterface(iLoggingEvent.getMessage(), formatMessageParameters(iLoggingEvent.getArgumentArray()))); eventBuilder.withSentryInterface(new ExceptionInterface(extractExceptionQueue(iLoggingEvent))); } else if (iLoggingEvent.getCallerData().length > 0) { eventBuilder.withSentryInterface(new StackTraceInterface(iLoggingEvent.getCallerData())); eventBuilder.withCulprit(iLoggingEvent.getCallerData()[0]); } else { eventBuilder.withCulprit(iLoggingEvent.getLoggerName()); eventBuilder.withExtra(contextEntry.getKey(), contextEntry.getValue()); eventBuilder.withTag(mdcEntry.getKey(), mdcEntry.getValue()); } else { eventBuilder.withExtra(mdcEntry.getKey(), mdcEntry.getValue()); eventBuilder.withTag(LOGBACK_MARKER, iLoggingEvent.getMarker().getName()); eventBuilder.withTag(tagEntry.getKey(), tagEntry.getValue()); return eventBuilder.build();
/** * Sends an exception to the Sentry server. * <p> * The Exception will be logged at the {@link Event.Level#ERROR} level. * * @param exception exception to send to Sentry. */ public void sendException(Exception exception) { EventBuilder eventBuilder = new EventBuilder().withMessage(exception.getMessage()) .withLevel(Event.Level.ERROR) .withSentryInterface(new ExceptionInterface(exception)); runBuilderHelpers(eventBuilder); sendEvent(eventBuilder.build()); }
/** * Adds a {@link SentryInterface} to the event. * <p> * If a {@code SentryInterface} with the same interface name has already been added, the new one will replace * the old one. * * @param sentryInterface sentry interface to add to the event. * @return the current {@code EventBuilder} for chained calls. * @deprecated use {@link #withSentryInterface(SentryInterface)} instead. */ @Deprecated public EventBuilder addSentryInterface(SentryInterface sentryInterface) { return withSentryInterface(sentryInterface); }
/** * Sets the culprit in the event. * * @param culprit culprit. * @return the current {@code EventBuilder} for chained calls. * @deprecated Use {@link #withCulprit(String)} instead. */ @Deprecated public EventBuilder setCulprit(String culprit) { return withCulprit(culprit); }
public void notify(String message, Throwable t, Map<String, String> extraData) { if (!raven.isPresent()) { return; } final StackTraceElement[] currentThreadStackTrace = Thread.currentThread().getStackTrace(); final EventBuilder eventBuilder = new EventBuilder() .withCulprit(getPrefix() + message) .withMessage(message) .withLevel(Event.Level.ERROR) .withLogger(getCallingClassName(currentThreadStackTrace)) .withSentryInterface(new ExceptionInterface(t)); final Optional<HttpServletRequest> maybeRequest = requestProvider.get(); if (maybeRequest.isPresent()) { eventBuilder.withSentryInterface(new HttpInterface(maybeRequest.get())); } if (extraData != null && !extraData.isEmpty()) { for (Map.Entry<String, String> entry : extraData.entrySet()) { eventBuilder.withExtra(entry.getKey(), entry.getValue()); } } sendEvent(raven.get(), eventBuilder); }
public void notify(String message, Throwable t, Map<String, String> extraData) { if (!raven.isPresent()) { return; } final StackTraceElement[] currentThreadStackTrace = Thread.currentThread().getStackTrace(); final EventBuilder eventBuilder = new EventBuilder() .withCulprit(getPrefix() + message) .withMessage(Strings.nullToEmpty(message)) .withLevel(Event.Level.ERROR) .withLogger(getCallingClassName(currentThreadStackTrace)) .withSentryInterface(new ExceptionInterface(t)); if (extraData != null && !extraData.isEmpty()) { for (Map.Entry<String, String> entry : extraData.entrySet()) { eventBuilder.addExtra(entry.getKey(), entry.getValue()); } } sendEvent(raven.get(), eventBuilder); }
/** * 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. * @deprecated use {@link #withSentryInterface(SentryInterface, boolean)} instead. */ @Deprecated public EventBuilder addSentryInterface(SentryInterface sentryInterface, boolean replace) { return withSentryInterface(sentryInterface, replace); }