public UDPTraceBrokerPlugin() 
{
        try {
            destination = new URI("udp://127.0.0.1:61616");
        } catch (URISyntaxException wontHappen) {
        }
}

 public  void acknowledge(ConsumerBrokerExchange consumerExchange,
    MessageAck ack) throws Exception 
{
        trace(ack);
        super.acknowledge(consumerExchange, ack);
}

 public  void addConnection(ConnectionContext context,
    ConnectionInfo info) throws Exception 
{
        trace(info);
        super.addConnection(context, info);
}

 public Subscription addConsumer(ConnectionContext context,
    ConsumerInfo info) throws Exception 
{
        trace(info);
        return super.addConsumer(context, info);
}

 public  void addDestinationInfo(ConnectionContext context,
    DestinationInfo info) throws Exception 
{
        trace(info);
        super.addDestinationInfo(context, info);
}

 public  void addProducer(ConnectionContext context,
    ProducerInfo info) throws Exception 
{
        trace(info);
        super.addProducer(context, info);
}

 public  void addSession(ConnectionContext context,
    SessionInfo info) throws Exception 
{
        trace(info);
        super.addSession(context, info);
}

 public  void beginTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        trace(new TransactionInfo(context.getConnectionId(), xid, TransactionInfo.BEGIN));
        super.beginTransaction(context, xid);
}

 public  void commitTransaction(ConnectionContext context,
    TransactionId xid,
    boolean onePhase) throws Exception 
{
        trace(new TransactionInfo(context.getConnectionId(), xid, onePhase ? TransactionInfo.COMMIT_ONE_PHASE : TransactionInfo.COMMIT_TWO_PHASE));
        super.commitTransaction(context, xid, onePhase);
}

 protected DatagramSocket createSocket() throws IOException 
{
        DatagramSocket s = new DatagramSocket();
        s.setSendBufferSize(maxTraceDatagramSize);
        s.setBroadcast(broadcast);
        return s;
}

 protected SocketAddress createSocketAddress(URI location) throws UnknownHostException 
{
        InetAddress a = InetAddress.getByName(location.getHost());
        int port = location.getPort();
        return new InetSocketAddress(a, port);
}

 protected WireFormat createWireFormat() 
{
        return getWireFormatFactory().createWireFormat();
}

 protected OpenWireFormatFactory createWireFormatFactory() 
{
        OpenWireFormatFactory wf = new OpenWireFormatFactory();
        wf.setCacheEnabled(false);
        wf.setVersion(1);
        wf.setTightEncodingEnabled(true);
        wf.setSizePrefixDisabled(true);
        return wf;
}

 public  void forgetTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        trace(new TransactionInfo(context.getConnectionId(), xid, TransactionInfo.FORGET));
        super.forgetTransaction(context, xid);
}

 public SocketAddress getAddress() 
{
        return address;
}

 public URI getDestination() 
{
        return destination;
}

 public int getMaxTraceDatagramSize() 
{
        return maxTraceDatagramSize;
}

 public WireFormat getWireFormat() 
{
        if (wireFormat == null) {
            wireFormat = createWireFormat();
        }
        return wireFormat;
}

 public WireFormatFactory getWireFormatFactory() 
{
        if (wireFormatFactory == null) {
            wireFormatFactory = createWireFormatFactory();
        }
        return wireFormatFactory;
}

 public boolean isBroadcast() 
{
        return broadcast;
}

 public Response messagePull(ConnectionContext context,
    MessagePull pull) throws Exception 
{
        trace(pull);
        return super.messagePull(context, pull);
}

 public  void postProcessDispatch(MessageDispatch messageDispatch) 
{
        trace(messageDispatch);
        super.postProcessDispatch(messageDispatch);
}

 public int prepareTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        trace(new TransactionInfo(context.getConnectionId(), xid, TransactionInfo.PREPARE));
        return super.prepareTransaction(context, xid);
}

 public  void processDispatchNotification(MessageDispatchNotification messageDispatchNotification) throws Exception 
{
        trace(messageDispatchNotification);
        super.processDispatchNotification(messageDispatchNotification);
}

 public  void removeConnection(ConnectionContext context,
    ConnectionInfo info,
    Throwable error) throws Exception 
{
        trace(info.createRemoveCommand());
        super.removeConnection(context, info, error);
}

 public  void removeConsumer(ConnectionContext context,
    ConsumerInfo info) throws Exception 
{
        trace(info.createRemoveCommand());
        super.removeConsumer(context, info);
}

 public  void removeDestination(ConnectionContext context,
    ActiveMQDestination destination,
    long timeout) throws Exception 
{
        super.removeDestination(context, destination, timeout);
}

 public  void removeDestinationInfo(ConnectionContext context,
    DestinationInfo info) throws Exception 
{
        trace(info);
        super.removeDestinationInfo(context, info);
}

 public  void removeProducer(ConnectionContext context,
    ProducerInfo info) throws Exception 
{
        trace(info.createRemoveCommand());
        super.removeProducer(context, info);
}

 public  void removeSession(ConnectionContext context,
    SessionInfo info) throws Exception 
{
        trace(info.createRemoveCommand());
        super.removeSession(context, info);
}

 public  void removeSubscription(ConnectionContext context,
    RemoveSubscriptionInfo info) throws Exception 
{
        trace(info);
        super.removeSubscription(context, info);
}

 public  void rollbackTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        trace(new TransactionInfo(context.getConnectionId(), xid, TransactionInfo.ROLLBACK));
        super.rollbackTransaction(context, xid);
}

 public  void send(ProducerBrokerExchange producerExchange,
    Message messageSend) throws Exception 
{
        trace(messageSend);
        super.send(producerExchange, messageSend);
}

 public  void setAddress(SocketAddress address) 
{
        this.address = address;
}

 public  void setBroadcast(boolean broadcast) 
{
        this.broadcast = broadcast;
}

 public  void setDestination(URI destination) 
{
        this.destination = destination;
}

 public  void setMaxTraceDatagramSize(int maxTraceDatagramSize) 
{
        this.maxTraceDatagramSize = maxTraceDatagramSize;
}

 public  void setWireFormat(WireFormat wireFormat) 
{
        this.wireFormat = wireFormat;
}

 public  void setWireFormatFactory(WireFormatFactory wireFormatFactory) 
{
        this.wireFormatFactory = wireFormatFactory;
}

 public  void start() throws Exception 
{
        super.start();
        if (getWireFormat() == null) {
            throw new IllegalArgumentException("Wireformat must be specifed.");
        }
        if (address == null) {
            address = createSocketAddress(destination);
        }
        socket = createSocket();
        brokerId = super.getBrokerId();
        trace(new JournalTrace("START"));
}

 public  void stop() throws Exception 
{
        trace(new JournalTrace("STOP"));
        socket.close();
        super.stop();
}