Add exception reporting events

2016-02-28 20:15:51 -05:00 · 2016-02-28 20:15:51 -05:00 · 010c651473
Commit 010c651473
--- a/Spigot-API-Patches/0021-Add-exception-reporting-event.patch
+++ b/Spigot-API-Patches/0021-Add-exception-reporting-event.patch
@ -0,0 +1,615 @@
 From 19bf0a56a0ee703d978da8e5f84999d1f5b20602 Mon Sep 17 00:00:00 2001
 From: Joseph Hirschfeld <joe@ibj.io>
 Date: Sat, 20 Feb 2016 20:07:46 -0500
 Subject: [PATCH] Add exception reporting event
 diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java
 index 12d9232..f35bc09 100644
 --- a/src/main/java/org/bukkit/command/SimpleCommandMap.java
 +++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java
@@ -17,6 +17,9 @@ import org.bukkit.Server;
 import org.bukkit.command.defaults.*;
 import org.bukkit.entity.Player;
 import org.bukkit.util.StringUtil;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerCommandException;
 +import org.github.paperspigot.exception.ServerTabCompleteException;
 public class SimpleCommandMap implements CommandMap {
     private static final Pattern PATTERN_ON_SPACE = Pattern.compile(" ", Pattern.LITERAL);
@@ -147,7 +150,9 @@ public class SimpleCommandMap implements CommandMap {
             throw ex;
         } catch (Throwable ex) {
             target.timings.stopTiming(); // Spigot
 -            throw new CommandException("Unhandled exception executing '" + commandLine + "' in " + target, ex);
 +            String msg = "Unhandled exception executing '" + commandLine + "' in " + target;
 +            server.getPluginManager().callEvent(new ServerExceptionEvent(new ServerCommandException(ex, target, sender, args))); // Paper
 +            throw new CommandException(msg, ex);
         }
         // return true as command was handled
@@ -224,7 +229,9 @@ public class SimpleCommandMap implements CommandMap {
         } catch (CommandException ex) {
             throw ex;
         } catch (Throwable ex) {
 -            throw new CommandException("Unhandled exception executing tab-completer for '" + cmdLine + "' in " + target, ex);
 +            String msg = "Unhandled exception executing tab-completer for '" + cmdLine + "' in " + target;
 +            server.getPluginManager().callEvent(new ServerExceptionEvent(new ServerTabCompleteException(msg, ex, target, sender, args))); // Paper
 +            throw new CommandException(msg, ex);
         }
     }
     // PaperSpigot end
 diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 index 1325b03..ce9839e 100644
 --- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 +++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
@@ -33,6 +33,9 @@ import org.bukkit.permissions.PermissionDefault;
 import org.bukkit.util.FileUtil;
 import com.google.common.collect.ImmutableSet;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerEventException;
 +import org.github.paperspigot.exception.ServerPluginEnableDisableException;
 /**
  * Handles all plugin management from the Server
@@ -403,7 +406,8 @@ public final class SimplePluginManager implements PluginManager {
             try {
                 plugin.getPluginLoader().enablePlugin(plugin);
             } catch (Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
 +                handlePluginException("Error occurred (in the plugin loader) while enabling "
 +                        + plugin.getDescription().getFullName() + " (Is it up to date?)", ex, plugin);
             }
             HandlerList.bakeAll();
@@ -422,36 +426,48 @@ public final class SimplePluginManager implements PluginManager {
             try {
                 plugin.getPluginLoader().disablePlugin(plugin);
             } catch (Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
 +                handlePluginException("Error occurred (in the plugin loader) while disabling "
 +                        + plugin.getDescription().getFullName() + " (Is it up to date?)", ex, plugin); // Paper
             }
             try {
                 server.getScheduler().cancelTasks(plugin);
             } catch (Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while cancelling tasks for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
 +                handlePluginException("Error occurred (in the plugin loader) while cancelling tasks for "
 +                        + plugin.getDescription().getFullName() + " (Is it up to date?)", ex, plugin); // Paper
             }
             try {
                 server.getServicesManager().unregisterAll(plugin);
             } catch (Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while unregistering services for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
 +                handlePluginException("Error occurred (in the plugin loader) while unregistering services for "
 +                        + plugin.getDescription().getFullName() + " (Is it up to date?)", ex, plugin); // Paper
             }
             try {
                 HandlerList.unregisterAll(plugin);
             } catch (Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while unregistering events for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
 +                handlePluginException("Error occurred (in the plugin loader) while unregistering events for "
 +                        + plugin.getDescription().getFullName() + " (Is it up to date?)", ex, plugin); // Paper
             }
             try {
                 server.getMessenger().unregisterIncomingPluginChannel(plugin);
                 server.getMessenger().unregisterOutgoingPluginChannel(plugin);
             } catch(Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while unregistering plugin channels for " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
 +                handlePluginException("Error occurred (in the plugin loader) while unregistering plugin channels for "
 +                        + plugin.getDescription().getFullName() + " (Is it up to date?)", ex, plugin); // Paper
             }
         }
     }
 +    // Paper start
 +    private void handlePluginException(String msg, Throwable ex, Plugin plugin) {
 +        server.getLogger().log(Level.SEVERE, msg, ex);
 +        callEvent(new ServerExceptionEvent(new ServerPluginEnableDisableException(msg, ex, plugin)));
 +    }
 +    // Paper end
 +
     public void clearPlugins() {
         synchronized (this) {
             disablePlugins();
@@ -513,7 +529,13 @@ public final class SimplePluginManager implements PluginManager {
                             ));
                 }
             } catch (Throwable ex) {
 -                server.getLogger().log(Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex);
 +                // Paper start - error reporting
 +                String msg = "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName();
 +                server.getLogger().log(Level.SEVERE, msg, ex);
 +                if (!(event instanceof ServerExceptionEvent)) { // We don't want to cause an endless event loop
 +                    callEvent(new ServerExceptionEvent(new ServerEventException(msg, ex, registration.getPlugin(), registration.getListener(), event)));
 +                }
 +                // Paper end
             }
         }
     }
 diff --git a/src/main/java/org/bukkit/plugin/messaging/StandardMessenger.java b/src/main/java/org/bukkit/plugin/messaging/StandardMessenger.java
 index 4c171e8..9ef6525 100644
 --- a/src/main/java/org/bukkit/plugin/messaging/StandardMessenger.java
 +++ b/src/main/java/org/bukkit/plugin/messaging/StandardMessenger.java
@@ -8,6 +8,8 @@ import java.util.Map;
 import java.util.Set;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerPluginMessageException;
 /**
  * Standard implementation to {@link Messenger}
@@ -427,7 +429,13 @@ public class StandardMessenger implements Messenger {
                 registration.getListener().onPluginMessageReceived( channel, source, message );
             } catch ( Throwable t )
             {
 -                org.bukkit.Bukkit.getLogger().log( java.util.logging.Level.WARNING, "Could not pass incoming plugin message to " + registration.getPlugin(), t );
 +                // Paper start
 +                String msg = "Could not pass incoming plugin message to " + registration.getPlugin();
 +                org.bukkit.Bukkit.getLogger().log( java.util.logging.Level.WARNING, msg, t );
 +                source.getServer().getPluginManager().callEvent(new ServerExceptionEvent(
 +                        new ServerPluginMessageException(msg, t, registration.getPlugin(), source, channel, message)
 +                ));
 +                // Paper end
             }
             // Spigot End
         }
 diff --git a/src/main/java/org/github/paperspigot/event/ServerExceptionEvent.java b/src/main/java/org/github/paperspigot/event/ServerExceptionEvent.java
 new file mode 100644
 index 0000000..317e9d2
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/event/ServerExceptionEvent.java
@@ -0,0 +1,36 @@
 +package org.github.paperspigot.event;
 +
 +import com.google.common.base.Preconditions;
 +import org.apache.commons.lang.Validate;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import org.github.paperspigot.exception.ServerException;
 +
 +/**
 + * Called whenever an exception is thrown in a recoverable section of the server.
 + */
 +public class ServerExceptionEvent extends Event {
 +    private static final HandlerList handlers = new HandlerList();
 +    private ServerException exception;
 +
 +    public ServerExceptionEvent (ServerException exception) {
 +        this.exception = Preconditions.checkNotNull(exception, "exception");
 +    }
 +
 +    /**
 +     * Gets the wrapped exception that was thrown.
 +     * @return Exception thrown
 +     */
 +    public ServerException getException() {
 +        return exception;
 +    }
 +
 +    @Override
 +    public HandlerList getHandlers() {
 +        return handlers;
 +    }
 +
 +    public static HandlerList getHandlerList() {
 +        return handlers;
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerCommandException.java b/src/main/java/org/github/paperspigot/exception/ServerCommandException.java
 new file mode 100644
 index 0000000..aae647a
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerCommandException.java
@@ -0,0 +1,64 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.command.Command;
 +import org.bukkit.command.CommandSender;
 +
 +import static com.google.common.base.Preconditions.checkNotNull;
 +
 +/**
 + * Thrown when a command throws an exception
 + */
 +public class ServerCommandException extends ServerException {
 +
 +    private final Command command;
 +    private final CommandSender commandSender;
 +    private final String[] arguments;
 +
 +    public ServerCommandException(String message, Throwable cause, Command command, CommandSender commandSender, String[] arguments) {
 +        super(message, cause);
 +        this.commandSender = checkNotNull(commandSender, "commandSender");
 +        this.arguments = checkNotNull(arguments, "arguments");
 +        this.command = checkNotNull(command, "command");
 +    }
 +
 +    public ServerCommandException(Throwable cause, Command command, CommandSender commandSender, String[] arguments) {
 +        super(cause);
 +        this.commandSender = checkNotNull(commandSender, "commandSender");
 +        this.arguments = checkNotNull(arguments, "arguments");
 +        this.command = checkNotNull(command, "command");
 +    }
 +
 +    protected ServerCommandException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Command command, CommandSender commandSender, String[] arguments) {
 +        super(message, cause, enableSuppression, writableStackTrace);
 +        this.commandSender = checkNotNull(commandSender, "commandSender");
 +        this.arguments = checkNotNull(arguments, "arguments");
 +        this.command = checkNotNull(command, "command");
 +    }
 +
 +    /**
 +     * Gets the command which threw the exception
 +     *
 +     * @return exception throwing command
 +     */
 +    public Command getCommand() {
 +        return command;
 +    }
 +
 +    /**
 +     * Gets the command sender which executed the command request
 +     *
 +     * @return command sender of exception thrown command request
 +     */
 +    public CommandSender getCommandSender() {
 +        return commandSender;
 +    }
 +
 +    /**
 +     * Gets the arguments which threw the exception for the command
 +     *
 +     * @return arguments of exception thrown command request
 +     */
 +    public String[] getArguments() {
 +        return arguments;
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerEventException.java b/src/main/java/org/github/paperspigot/exception/ServerEventException.java
 new file mode 100644
 index 0000000..d99cab8
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerEventException.java
@@ -0,0 +1,52 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.event.Event;
 +import org.bukkit.event.Listener;
 +import org.bukkit.plugin.Plugin;
 +
 +import static com.google.common.base.Preconditions.*;
 +
 +/**
 + * Exception thrown when a server event listener throws an exception
 + */
 +public class ServerEventException extends ServerPluginException {
 +
 +    private final Listener listener;
 +    private final Event event;
 +
 +    public ServerEventException(String message, Throwable cause, Plugin responsiblePlugin, Listener listener, Event event) {
 +        super(message, cause, responsiblePlugin);
 +        this.listener = checkNotNull(listener, "listener");
 +        this.event = checkNotNull(event, "event");
 +    }
 +
 +    public ServerEventException(Throwable cause, Plugin responsiblePlugin, Listener listener, Event event) {
 +        super(cause, responsiblePlugin);
 +        this.listener = checkNotNull(listener, "listener");
 +        this.event = checkNotNull(event, "event");
 +    }
 +
 +    protected ServerEventException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Plugin responsiblePlugin, Listener listener, Event event) {
 +        super(message, cause, enableSuppression, writableStackTrace, responsiblePlugin);
 +        this.listener = checkNotNull(listener, "listener");
 +        this.event = checkNotNull(event, "event");
 +    }
 +
 +    /**
 +     * Gets the listener which threw the exception
 +     *
 +     * @return event listener
 +     */
 +    public Listener getListener() {
 +        return listener;
 +    }
 +
 +    /**
 +     * Gets the event which caused the exception
 +     *
 +     * @return event
 +     */
 +    public Event getEvent() {
 +        return event;
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerException.java b/src/main/java/org/github/paperspigot/exception/ServerException.java
 new file mode 100644
 index 0000000..f7aad05
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerException.java
@@ -0,0 +1,23 @@
 +package org.github.paperspigot.exception;
 +
 +/**
 + * Wrapper exception for all exceptions that are thrown by the server.
 + */
 +public class ServerException extends Exception {
 +
 +    public ServerException(String message) {
 +        super(message);
 +    }
 +
 +    public ServerException(String message, Throwable cause) {
 +        super(message, cause);
 +    }
 +
 +    public ServerException(Throwable cause) {
 +        super(cause);
 +    }
 +
 +    protected ServerException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
 +        super(message, cause, enableSuppression, writableStackTrace);
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerInternalException.java b/src/main/java/org/github/paperspigot/exception/ServerInternalException.java
 new file mode 100644
 index 0000000..17ad4cb
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerInternalException.java
@@ -0,0 +1,35 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.Bukkit;
 +import org.bukkit.entity.ThrownExpBottle;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +
 +/**
 + * Thrown when the internal server throws a recoverable exception.
 + */
 +public class ServerInternalException extends ServerException {
 +
 +    public ServerInternalException(String message) {
 +        super(message);
 +    }
 +
 +    public ServerInternalException(String message, Throwable cause) {
 +        super(message, cause);
 +    }
 +
 +    public ServerInternalException(Throwable cause) {
 +        super(cause);
 +    }
 +
 +    protected ServerInternalException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
 +        super(message, cause, enableSuppression, writableStackTrace);
 +    }
 +
 +    public static void reportInternalException(Throwable cause) {
 +        try {
 +            Bukkit.getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(cause)));;
 +        } catch (Throwable t) {
 +            t.printStackTrace(); // Don't want to rethrow!
 +        }
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerPluginEnableDisableException.java b/src/main/java/org/github/paperspigot/exception/ServerPluginEnableDisableException.java
 new file mode 100644
 index 0000000..8c938d0
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerPluginEnableDisableException.java
@@ -0,0 +1,20 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.plugin.Plugin;
 +
 +/**
 + * Thrown whenever there is an exception with any enabling or disabling of plugins.
 + */
 +public class ServerPluginEnableDisableException extends ServerPluginException {
 +    public ServerPluginEnableDisableException(String message, Throwable cause, Plugin responsiblePlugin) {
 +        super(message, cause, responsiblePlugin);
 +    }
 +
 +    public ServerPluginEnableDisableException(Throwable cause, Plugin responsiblePlugin) {
 +        super(cause, responsiblePlugin);
 +    }
 +
 +    protected ServerPluginEnableDisableException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Plugin responsiblePlugin) {
 +        super(message, cause, enableSuppression, writableStackTrace, responsiblePlugin);
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerPluginException.java b/src/main/java/org/github/paperspigot/exception/ServerPluginException.java
 new file mode 100644
 index 0000000..f9241ad
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerPluginException.java
@@ -0,0 +1,39 @@
 +package org.github.paperspigot.exception;
 +
 +import com.google.common.base.Preconditions;
 +import org.apache.commons.lang.Validate;
 +import org.bukkit.plugin.Plugin;
 +
 +import static com.google.common.base.Preconditions.*;
 +
 +/**
 + * Wrapper exception for all cases to which a plugin can be immediately blamed for
 + */
 +public class ServerPluginException extends ServerException {
 +    public ServerPluginException(String message, Throwable cause, Plugin responsiblePlugin) {
 +        super(message, cause);
 +        this.responsiblePlugin = checkNotNull(responsiblePlugin, "responsiblePlugin");
 +    }
 +
 +    public ServerPluginException(Throwable cause, Plugin responsiblePlugin) {
 +        super(cause);
 +        this.responsiblePlugin = checkNotNull(responsiblePlugin, "responsiblePlugin");
 +    }
 +
 +    protected ServerPluginException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Plugin responsiblePlugin) {
 +        super(message, cause, enableSuppression, writableStackTrace);
 +        this.responsiblePlugin = checkNotNull(responsiblePlugin, "responsiblePlugin");
 +    }
 +
 +    private final Plugin responsiblePlugin;
 +
 +    /**
 +     * Gets the plugin which is directly responsible for the exception being thrown
 +     *
 +     * @return plugin which is responsible for the exception throw
 +     */
 +    public Plugin getResponsiblePlugin() {
 +        return responsiblePlugin;
 +    }
 +
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerPluginMessageException.java b/src/main/java/org/github/paperspigot/exception/ServerPluginMessageException.java
 new file mode 100644
 index 0000000..b71303b
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerPluginMessageException.java
@@ -0,0 +1,61 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.entity.Player;
 +import org.bukkit.plugin.Plugin;
 +
 +import static com.google.common.base.Preconditions.*;
 +
 +/**
 + * Thrown when an incoming plugin message channel throws an exception
 + */
 +public class ServerPluginMessageException extends ServerPluginException {
 +
 +    private final Player player;
 +    private final String channel;
 +    private final byte[] data;
 +
 +    public ServerPluginMessageException(String message, Throwable cause, Plugin responsiblePlugin, Player player, String channel, byte[] data) {
 +        super(message, cause, responsiblePlugin);
 +        this.player = checkNotNull(player, "player");
 +        this.channel = checkNotNull(channel, "channel");
 +        this.data = checkNotNull(data, "data");
 +    }
 +
 +    public ServerPluginMessageException(Throwable cause, Plugin responsiblePlugin, Player player, String channel, byte[] data) {
 +        super(cause, responsiblePlugin);
 +        this.player = checkNotNull(player, "player");
 +        this.channel = checkNotNull(channel, "channel");
 +        this.data = checkNotNull(data, "data");
 +    }
 +
 +    protected ServerPluginMessageException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Plugin responsiblePlugin, Player player, String channel, byte[] data) {
 +        super(message, cause, enableSuppression, writableStackTrace, responsiblePlugin);
 +        this.player = checkNotNull(player, "player");
 +        this.channel = checkNotNull(channel, "channel");
 +        this.data = checkNotNull(data, "data");
 +    }
 +
 +    /**
 +     * Gets the channel to which the error occurred from recieving data from
 +     * @return exception channel
 +     */
 +    public String getChannel() {
 +        return channel;
 +    }
 +
 +    /**
 +     * Gets the data to which the error occurred from
 +     * @return exception data
 +     */
 +    public byte[] getData() {
 +        return data;
 +    }
 +
 +    /**
 +     * Gets the player which the plugin message causing the exception originated from
 +     * @return  exception player
 +     */
 +    public Player getPlayer() {
 +        return player;
 +    }
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerSchedulerException.java b/src/main/java/org/github/paperspigot/exception/ServerSchedulerException.java
 new file mode 100644
 index 0000000..99757ee
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerSchedulerException.java
@@ -0,0 +1,37 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.scheduler.BukkitTask;
 +
 +import static com.google.common.base.Preconditions.checkNotNull;
 +
 +/**
 + * Thrown when a plugin's scheduler fails with an exception
 + */
 +public class ServerSchedulerException extends ServerPluginException {
 +
 +    private final BukkitTask task;
 +
 +    public ServerSchedulerException(String message, Throwable cause, BukkitTask task) {
 +        super(message, cause, task.getOwner());
 +        this.task = checkNotNull(task, "task");
 +    }
 +
 +    public ServerSchedulerException(Throwable cause, BukkitTask task) {
 +        super(cause, task.getOwner());
 +        this.task = checkNotNull(task, "task");
 +    }
 +
 +    protected ServerSchedulerException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, BukkitTask task) {
 +        super(message, cause, enableSuppression, writableStackTrace, task.getOwner());
 +        this.task = checkNotNull(task, "task");
 +    }
 +
 +    /**
 +     * Gets the task which threw the exception
 +     * @return exception throwing task
 +     */
 +    public BukkitTask getTask() {
 +        return task;
 +    }
 +
 +}
 diff --git a/src/main/java/org/github/paperspigot/exception/ServerTabCompleteException.java b/src/main/java/org/github/paperspigot/exception/ServerTabCompleteException.java
 new file mode 100644
 index 0000000..6e1e2ab
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/exception/ServerTabCompleteException.java
@@ -0,0 +1,22 @@
 +package org.github.paperspigot.exception;
 +
 +import org.bukkit.command.Command;
 +import org.bukkit.command.CommandSender;
 +
 +/**
 + * Called when a tab-complete request throws an exception
 + */
 +public class ServerTabCompleteException extends ServerCommandException {
 +
 +    public ServerTabCompleteException(String message, Throwable cause, Command command, CommandSender commandSender, String[] arguments) {
 +        super(message, cause, command, commandSender, arguments);
 +    }
 +
 +    public ServerTabCompleteException(Throwable cause, Command command, CommandSender commandSender, String[] arguments) {
 +        super(cause, command, commandSender, arguments);
 +    }
 +
 +    protected ServerTabCompleteException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, Command command, CommandSender commandSender, String[] arguments) {
 +        super(message, cause, enableSuppression, writableStackTrace, command, commandSender, arguments);
 +    }
 +}
 -- 
 2.5.0
--- a/Spigot-Server-Patches/0100-Add-exception-reporting-event.patch
+++ b/Spigot-Server-Patches/0100-Add-exception-reporting-event.patch
@ -0,0 +1,466 @@
 From 3222d65f280871d3cc7b9a3d0250934dcc5f456c Mon Sep 17 00:00:00 2001
 From: Joseph Hirschfeld <joe@ibj.io>
 Date: Sat, 20 Feb 2016 20:07:46 -0500
 Subject: [PATCH] Add exception reporting event
 diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
 index aa555f5..ab0d41c 100644
 --- a/src/main/java/net/minecraft/server/Chunk.java
 +++ b/src/main/java/net/minecraft/server/Chunk.java
@@ -18,6 +18,9 @@ import org.apache.logging.log4j.Logger;
 import com.google.common.collect.Lists; // CraftBukkit
 import org.bukkit.Bukkit; // CraftBukkit
 +import org.bukkit.craftbukkit.util.CraftMagicNumbers;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerInternalException;
 public class Chunk {
@@ -869,10 +872,15 @@ public class Chunk {
             this.tileEntities.remove(blockposition);
             // PaperSpigot end
         } else {
 -            System.out.println("Attempted to place a tile entity (" + tileentity + ") at " + tileentity.position.getX() + "," + tileentity.position.getY() + "," + tileentity.position.getZ()
 -                + " (" + org.bukkit.craftbukkit.util.CraftMagicNumbers.getMaterial(getType(blockposition)) + ") where there was no entity tile!");
 -            System.out.println("Chunk coordinates: " + (this.locX * 16) + "," + (this.locZ * 16));
 -            new Exception().printStackTrace();
 +            // Paper start
 +            ServerInternalException e = new ServerInternalException(
 +                    "Attempted to place a tile entity (" + tileentity + ") at " + tileentity.position.getX() + ","
 +                    + tileentity.position.getY() + "," + tileentity.position.getZ()
 +                    + " (" + CraftMagicNumbers.getMaterial(getType(blockposition)) + ") where there was no entity tile!\n" +
 +                    "Chunk coordinates: " + (this.locX * 16) + "," + (this.locZ * 16));
 +            e.printStackTrace();
 +            ServerInternalException.reportInternalException(e);
 +            // Paper end
             // CraftBukkit end
         }
     }
 diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
 index 0e6a37f..c4dab42 100644
 --- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
 +++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
@@ -15,12 +15,15 @@ import org.apache.logging.log4j.Logger;
 import java.util.Random;
 import java.util.logging.Level;
 +import org.bukkit.Bukkit;
 import org.bukkit.Server;
 import org.bukkit.craftbukkit.chunkio.ChunkIOExecutor;
 import org.bukkit.craftbukkit.util.LongHash;
 import org.bukkit.craftbukkit.util.LongHashSet;
 import org.bukkit.craftbukkit.util.LongObjectHashMap;
 import org.bukkit.event.world.ChunkUnloadEvent;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerInternalException;
 // CraftBukkit end
 public class ChunkProviderServer implements IChunkProvider {
@@ -215,11 +218,14 @@ public class ChunkProviderServer implements IChunkProvider {
         if (chunk == emptyChunk) return chunk;
         if (i != chunk.locX || j != chunk.locZ) {
 -            b.error("Chunk (" + chunk.locX + ", " + chunk.locZ + ") stored at  (" + i + ", " + j + ") in world '" + world.getWorld().getName() + "'");
 +            // Paper start
 +            String msg = "Chunk (" + chunk.locX + ", " + chunk.locZ + ") stored at  (" + i + ", " + j + ") in world '" + world.getWorld().getName() + "'";
 +            b.error(msg);
             b.error(chunk.getClass().getName());
 -            Throwable ex = new Throwable();
 -            ex.fillInStackTrace();
 +            ServerInternalException ex = new ServerInternalException(msg);
             ex.printStackTrace();
 +            Bukkit.getPluginManager().callEvent(new ServerExceptionEvent(ex));
 +            // Paper end
         }
         return chunk;
@@ -244,7 +250,11 @@ public class ChunkProviderServer implements IChunkProvider {
                 return chunk;
             } catch (Exception exception) {
 -                ChunkProviderServer.b.error("Couldn\'t load chunk", exception);
 +                // Paper start
 +                String msg = "Couldn\'t load chunk";
 +                ChunkProviderServer.b.error(msg, exception);
 +                ServerInternalException.reportInternalException(exception);
 +                // Paper end
                 return null;
             }
         }
 diff --git a/src/main/java/net/minecraft/server/NameReferencingFileConverter.java b/src/main/java/net/minecraft/server/NameReferencingFileConverter.java
 index d67539c..4029109 100644
 --- a/src/main/java/net/minecraft/server/NameReferencingFileConverter.java
 +++ b/src/main/java/net/minecraft/server/NameReferencingFileConverter.java
@@ -25,6 +25,9 @@ import java.util.Map;
 import java.util.UUID;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 +import org.bukkit.Bukkit;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerInternalException;
 public class NameReferencingFileConverter {
@@ -361,6 +364,7 @@ public class NameReferencingFileConverter {
                             root = NBTCompressedStreamTools.a(new java.io.FileInputStream(file1));
                         } catch (Exception exception) {
                             exception.printStackTrace();
 +                            ServerInternalException.reportInternalException(exception); // Paper
                         }
                         if (root != null) {
@@ -374,8 +378,9 @@ public class NameReferencingFileConverter {
                                 NBTCompressedStreamTools.a(root, new java.io.FileOutputStream(file2));
                             } catch (Exception exception) {
                                 exception.printStackTrace();
 +                                ServerInternalException.reportInternalException(exception); // Paper
                             }
 -                       }
 +                        }
                         // CraftBukkit end
                         NameReferencingFileConverter.b(file);
 diff --git a/src/main/java/net/minecraft/server/PersistentCollection.java b/src/main/java/net/minecraft/server/PersistentCollection.java
 index 451f481..6459594 100644
 --- a/src/main/java/net/minecraft/server/PersistentCollection.java
 +++ b/src/main/java/net/minecraft/server/PersistentCollection.java
@@ -2,6 +2,10 @@ package net.minecraft.server;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 +import org.bukkit.Bukkit;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerInternalException;
 +
 import java.io.DataInputStream;
 import java.io.DataOutput;
 import java.io.DataOutputStream;
@@ -103,6 +107,7 @@ public class PersistentCollection {
                 }
             } catch (Exception exception) {
                 exception.printStackTrace();
 +                ServerInternalException.reportInternalException(exception);
             }
         }
@@ -176,6 +181,7 @@ public class PersistentCollection {
                 }
             } catch (Exception exception) {
                 exception.printStackTrace();
 +                ServerInternalException.reportInternalException(exception); // Paper
             }
             return oshort.shortValue();
 diff --git a/src/main/java/net/minecraft/server/RegionFile.java b/src/main/java/net/minecraft/server/RegionFile.java
 index 348706f..8165a50 100644
 --- a/src/main/java/net/minecraft/server/RegionFile.java
 +++ b/src/main/java/net/minecraft/server/RegionFile.java
@@ -1,6 +1,8 @@
 package net.minecraft.server;
 import com.google.common.collect.Lists;
 +import org.github.paperspigot.exception.ServerInternalException;
 +
 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -82,6 +84,7 @@ public class RegionFile {
             }
         } catch (IOException ioexception) {
             ioexception.printStackTrace();
 +            ServerInternalException.reportInternalException(ioexception); // Paper
         }
     }
@@ -247,6 +250,7 @@ public class RegionFile {
             this.b(i, j, (int) (MinecraftServer.az() / 1000L));
         } catch (IOException ioexception) {
             ioexception.printStackTrace();
 +            ServerInternalException.reportInternalException(ioexception); // Paper
         }
     }
 diff --git a/src/main/java/net/minecraft/server/RegionFileCache.java b/src/main/java/net/minecraft/server/RegionFileCache.java
 index 5b000c4..4cfaf30 100644
 --- a/src/main/java/net/minecraft/server/RegionFileCache.java
 +++ b/src/main/java/net/minecraft/server/RegionFileCache.java
@@ -1,6 +1,8 @@
 package net.minecraft.server;
 import com.google.common.collect.Maps;
 +import org.github.paperspigot.exception.ServerInternalException;
 +
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.File;
@@ -53,6 +55,7 @@ public class RegionFileCache {
                 }
             } catch (IOException ioexception) {
                 ioexception.printStackTrace();
 +                ServerInternalException.reportInternalException(ioexception); // Paper
             }
         }
 diff --git a/src/main/java/net/minecraft/server/SpawnerCreature.java b/src/main/java/net/minecraft/server/SpawnerCreature.java
 index 611b8fd..284f4bf 100644
 --- a/src/main/java/net/minecraft/server/SpawnerCreature.java
 +++ b/src/main/java/net/minecraft/server/SpawnerCreature.java
@@ -10,6 +10,7 @@ import java.util.Set;
 import org.bukkit.craftbukkit.util.LongHash;
 import org.bukkit.craftbukkit.util.LongHashSet;
 import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
 +import org.github.paperspigot.exception.ServerInternalException;
 // CraftBukkit end
 public final class SpawnerCreature {
@@ -171,6 +172,7 @@ public final class SpawnerCreature {
                                                             entityinsentient = (EntityInsentient) biomebase_biomemeta.b.getConstructor(new Class[] { World.class}).newInstance(new Object[] { worldserver});
                                                         } catch (Exception exception) {
                                                             exception.printStackTrace();
 +                                                            ServerInternalException.reportInternalException(exception); // Paper
                                                             return j1;
                                                         }
@@ -276,6 +278,7 @@ public final class SpawnerCreature {
                                 entityinsentient = (EntityInsentient) biomebase_biomemeta.b.getConstructor(new Class[] { World.class}).newInstance(new Object[] { world});
                             } catch (Exception exception) {
                                 exception.printStackTrace();
 +                                ServerInternalException.reportInternalException(exception); // Paper
                                 continue;
                             }
 diff --git a/src/main/java/net/minecraft/server/TileEntity.java b/src/main/java/net/minecraft/server/TileEntity.java
 index fdcbf44..f68b132 100644
 --- a/src/main/java/net/minecraft/server/TileEntity.java
 +++ b/src/main/java/net/minecraft/server/TileEntity.java
@@ -9,6 +9,7 @@ import org.apache.logging.log4j.Logger;
 import co.aikar.timings.SpigotTimings; // Spigot
 import co.aikar.timings.Timing; // Spigot
 import org.bukkit.inventory.InventoryHolder; // CraftBukkit
 +import org.github.paperspigot.exception.ServerInternalException;
 public abstract class TileEntity {
@@ -76,6 +77,7 @@ public abstract class TileEntity {
             }
         } catch (Exception exception) {
             exception.printStackTrace();
 +            ServerInternalException.reportInternalException(exception); // Paper
         }
         if (tileentity != null) {
 diff --git a/src/main/java/net/minecraft/server/VillageSiege.java b/src/main/java/net/minecraft/server/VillageSiege.java
 index 42d6737..01dbc98 100644
 --- a/src/main/java/net/minecraft/server/VillageSiege.java
 +++ b/src/main/java/net/minecraft/server/VillageSiege.java
@@ -1,5 +1,7 @@
 package net.minecraft.server;
 +import org.github.paperspigot.exception.ServerInternalException;
 +
 import java.util.Iterator;
 import java.util.List;
@@ -136,6 +138,7 @@ public class VillageSiege {
                 entityzombie.setVillager(false);
             } catch (Exception exception) {
                 exception.printStackTrace();
 +                ServerInternalException.reportInternalException(exception); // Paper
                 return false;
             }
 diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java
 index f0cd810..8f3511f 100644
 --- a/src/main/java/net/minecraft/server/World.java
 +++ b/src/main/java/net/minecraft/server/World.java
@@ -24,6 +24,8 @@ import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerInternalException;
 // PaperSpigot end
 // CraftBukkit start
@@ -1450,8 +1452,10 @@ public abstract class World implements IBlockAccess {
                 } catch (Throwable throwable1) {
                     // PaperSpigot start - Prevent tile entity and entity crashes
                     entity.tickTimer.stopTiming();
 -                    System.err.println("Entity threw exception at " + entity.world.getWorld().getName() + ":" + entity.locX + "," + entity.locY + "," + entity.locZ);
 +                    String msg = "Entity threw exception at " + entity.world.getWorld().getName() + ":" + entity.locX + "," + entity.locY + "," + entity.locZ;
 +                    System.err.println(msg);
                     throwable1.printStackTrace();
 +                    getServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable1)));
                     entity.dead = true;
                     continue;
                     // PaperSpigot end
@@ -1513,8 +1517,10 @@ public abstract class World implements IBlockAccess {
                     } catch (Throwable throwable2) {
                         // PaperSpigot start - Prevent tile entity and entity crashes
                         tileentity.tickTimer.stopTiming();
 -                        System.err.println("TileEntity threw exception at " + tileentity.world.getWorld().getName() + ":" + tileentity.position.getX() + "," + tileentity.position.getY() + "," + tileentity.position.getZ());
 +                        String msg = "TileEntity threw exception at " + tileentity.world.getWorld().getName() + ":" + tileentity.position.getX() + "," + tileentity.position.getY() + "," + tileentity.position.getZ();
 +                        System.err.println(msg);
                         throwable2.printStackTrace();
 +                        getServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable2)));
                         tilesThisCycle--;
                         this.tileEntityList.remove(tileTickPosition--);
                         continue;
 diff --git a/src/main/java/net/minecraft/server/WorldNBTStorage.java b/src/main/java/net/minecraft/server/WorldNBTStorage.java
 index e5124af..b4056a2 100644
 --- a/src/main/java/net/minecraft/server/WorldNBTStorage.java
 +++ b/src/main/java/net/minecraft/server/WorldNBTStorage.java
@@ -15,6 +15,7 @@ import org.apache.logging.log4j.Logger;
 import java.util.UUID;
 import org.bukkit.craftbukkit.entity.CraftPlayer;
 +import org.github.paperspigot.exception.ServerInternalException;
 // CraftBukkit end
 public class WorldNBTStorage implements IDataManager, IPlayerFileData {
@@ -96,6 +97,7 @@ public class WorldNBTStorage implements IDataManager, IPlayerFileData {
                 return new WorldData(nbttagcompound1);
             } catch (Exception exception) {
                 exception.printStackTrace();
 +                ServerInternalException.reportInternalException(exception); // Paper
             }
         }
@@ -107,6 +109,7 @@ public class WorldNBTStorage implements IDataManager, IPlayerFileData {
                 return new WorldData(nbttagcompound1);
             } catch (Exception exception1) {
                 exception1.printStackTrace();
 +                ServerInternalException.reportInternalException(exception1); // Paper
             }
         }
@@ -140,6 +143,7 @@ public class WorldNBTStorage implements IDataManager, IPlayerFileData {
             }
         } catch (Exception exception) {
             exception.printStackTrace();
 +            ServerInternalException.reportInternalException(exception); // Paper
         }
     }
@@ -171,6 +175,7 @@ public class WorldNBTStorage implements IDataManager, IPlayerFileData {
             }
         } catch (Exception exception) {
             exception.printStackTrace();
 +            ServerInternalException.reportInternalException(exception); // Paper
         }
     }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 index 72c0b17..7640070 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
@@ -55,6 +55,7 @@ import org.bukkit.metadata.MetadataValue;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.messaging.StandardMessenger;
 import org.bukkit.util.Vector;
 +import org.github.paperspigot.exception.ServerInternalException;
 public class CraftWorld implements World {
     public static final int CUSTOM_DIMENSION_OFFSET = 10;
@@ -778,6 +779,7 @@ public class CraftWorld implements World {
             world.savingDisabled = oldSave;
         } catch (ExceptionWorldConflict ex) {
             ex.printStackTrace();
 +            ServerInternalException.reportInternalException(ex); // Paper
         }
     }
 diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
 index d76ec40..f036709 100644
 --- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
 +++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
@@ -21,6 +21,9 @@ import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.scheduler.BukkitScheduler;
 import org.bukkit.scheduler.BukkitTask;
 import org.bukkit.scheduler.BukkitWorker;
 +import org.github.paperspigot.ServerSchedulerReportingWrapper;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerSchedulerException;
 /**
  * The fundamental concepts for this implementation:
@@ -348,18 +351,24 @@ public class CraftScheduler implements BukkitScheduler {
                 try {
                     task.run();
                 } catch (final Throwable throwable) {
 +                    // Paper start
 +                    String msg = String.format(
 +                            "Task #%s for %s generated an exception",
 +                            task.getTaskId(),
 +                            task.getOwner().getDescription().getFullName());
                     task.getOwner().getLogger().log(
                             Level.WARNING,
 -                            String.format(
 -                                "Task #%s for %s generated an exception",
 -                                task.getTaskId(),
 -                                task.getOwner().getDescription().getFullName()),
 +                            msg,
                             throwable);
 +                    task.getOwner().getServer().getPluginManager().callEvent(
 +                            new ServerExceptionEvent(new ServerSchedulerException(msg, throwable, task))
 +                    );
 +                    // Paper end
                 }
                 parsePending();
             } else {
                 debugTail = debugTail.setNext(new CraftAsyncDebugger(currentTick + RECENT_TICKS, task.getOwner(), task.getTaskClass()));
 -                executor.execute(task);
 +                executor.execute(new ServerSchedulerReportingWrapper(task)); // Paper
                 // We don't need to parse pending
                 // (async tasks must live with race-conditions if they attempt to cancel between these few lines of code)
             }
 diff --git a/src/main/java/org/github/paperspigot/ServerSchedulerReportingWrapper.java b/src/main/java/org/github/paperspigot/ServerSchedulerReportingWrapper.java
 new file mode 100644
 index 0000000..6499373
 --- /dev/null
 +++ b/src/main/java/org/github/paperspigot/ServerSchedulerReportingWrapper.java
@@ -0,0 +1,39 @@
 +package org.github.paperspigot;
 +
 +import com.google.common.base.Preconditions;
 +import org.apache.commons.lang.Validate;
 +import org.bukkit.craftbukkit.scheduler.CraftTask;
 +import org.github.paperspigot.event.ServerExceptionEvent;
 +import org.github.paperspigot.exception.ServerSchedulerException;
 +
 +/**
 + * Reporting wrapper to catch exceptions not natively
 + */
 +public class ServerSchedulerReportingWrapper implements Runnable {
 +
 +    private final CraftTask internalTask;
 +
 +    public ServerSchedulerReportingWrapper(CraftTask internalTask) {
 +        this.internalTask = Preconditions.checkNotNull(internalTask, "internalTask");
 +    }
 +
 +    @Override
 +    public void run() {
 +        try {
 +            internalTask.run();
 +        } catch (RuntimeException e) {
 +            internalTask.getOwner().getServer().getPluginManager().callEvent(
 +                    new ServerExceptionEvent(new ServerSchedulerException(e, internalTask))
 +            );
 +            throw e;
 +        } catch (Throwable t) {
 +            internalTask.getOwner().getServer().getPluginManager().callEvent(
 +                    new ServerExceptionEvent(new ServerSchedulerException(t, internalTask))
 +            ); //Do not rethrow, since it is not permitted with Runnable#run
 +        }
 +    }
 +
 +    public CraftTask getInternalTask() {
 +        return internalTask;
 +    }
 +}
 -- 
 2.5.0