* {@return true if the <b>debug</b> error level is enabled}
     */
    boolean isDebugEnabled();

    /**
     * Sends a message to the user in the <b>debug</b> error level.
     *
     * @param content the message to log
     */
    void debug(CharSequence content);

    /**
     * Sends a message (and accompanying exception) to the user in the <b>debug</b> error level.

    /** Line feed character for message formatting. */
    protected static final char LF = '\n';

    /**
     * Sends notifications to configured platforms.
     *
     * @param cardView the card view for the notification
     * @param discloser the mail posting discloser
     */
    public void send(final CardView cardView, final SMailPostingDiscloser discloser) {
        sendToSlack(cardView, discloser);

Below is the protocol in some more detail:

1. The client looks for a compatible idle daemon. If there isn't one, it starts a new daemon.
2. The client connects to the idle daemon and sends it a request to do some work. If the daemon is no longer running, the client starts again.

* «type annotations»: «annotations de type»

* «autocomplete»: «autocomplétion»
* «autocompletion»: «autocomplétion»

* «the request» (what the client sends to the server): «la requête»
* «the response» (what the server sends back to the client): «la réponse»

* «the request body»: «le corps de la requête»
* «the response body»: «le corps de la réponse»

* «path operation»: «opération de chemin»

    /**
     * Sends an SMB request and returns the response
     * @param <T> the response type
     * @param request the request to send
     * @param params optional request parameters
     * @return response message
     * @throws CIFSException if an error occurs sending the request
     */
    <T extends CommonServerMessageBlockResponse> T send(Request<T> request, RequestParam... params) throws CIFSException;

		return err
	}
	if err := target.init(); err != nil {
		return err
	}
	err := target.send(eventData)
	if err != nil {
		if xnet.IsNetworkOrHostDown(err, false) {
			return store.ErrNotConnected
		}
	}
	return err
}

// send - sends an event to the webhook.
func (target *WebhookTarget) send(eventData event.Event) error {
	objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
	if err != nil {

		return err
	}
	if err := target.init(); err != nil {
		return err
	}
	_, err := target.isActive()
	if err != nil {
		return err
	}
	return target.send(eventData)
}

// send - sends an event to the redis.
func (target *RedisTarget) send(eventData event.Event) error {
	conn := target.pool.Get()
	defer conn.Close()

	if target.args.Format == event.NamespaceFormat {

	}

	if err := target.init(); err != nil {
		return err
	}

	_, err := target.isActive()
	if err != nil {
		return err
	}
	return target.send(eventData)
}

// send - sends an event to the NSQ.
func (target *NSQTarget) send(eventData event.Event) error {
	objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
	if err != nil {
		return err
	}

So, if your API user (the external developer) sends a request to *your API* to:

```
https://yourapi.com/invoices/?callback_url=https://www.external.org/events
```

with a JSON body of:

```JSON
{
    "id": "2expen51ve",
    "customer": "Mr. Richie Rich",
    "total": "9999"
}
```

}

func (target *MQTTTarget) isActive() (bool, error) {
	if !target.client.IsConnectionOpen() {
		return false, store.ErrNotConnected
	}
	return true, nil
}

// send - sends an event to the mqtt.
func (target *MQTTTarget) send(eventData event.Event) error {
	objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
	if err != nil {
		return err
	}
	key := eventData.S3.Bucket.Name + "/" + objectName