}

// ID - returns target ID.
func (target *WebhookTarget) ID() event.TargetID {
	return target.id
}

// IsActive - Return true if target is up and active
func (target *WebhookTarget) IsActive() (bool, error) {
	if err := target.init(); err != nil {
		return false, err
	}
	return target.isActive()
}

// errNotConnected - indicates that the target connection is not active.

| `minio_notify_events_errors_total`             | Events that were failed to be sent to the targets (deprecated, please use `minio_notify_target_failed_events` instead)                      |

            String p2 = parents.get(1);
            if (p1.equals(targetSha)) {
                prHead = p2;
            } else if (p2.equals(targetSha)) {
                prHead = p1;
            }
        }

        String baseSha = stdout("git", "merge-base", targetSha, prHead).trim();

        System.err.println("Target branch: " + targetBranch + " (" + targetSha + ")");
        System.err.println("PR head: " + prHead);

	auditTotalMessages     = "total_messages"
	targetID               = "target_id"
)

var (
	auditFailedMessagesMD = NewCounterMD(auditFailedMessages,
		"Total number of messages that failed to send since start",
		targetID)
	auditTargetQueueLengthMD = NewGaugeMD(auditTargetQueueLength,
		"Number of unsent messages in queue for target",
		targetID)
	auditTotalMessagesMD = NewCounterMD(auditTotalMessages,

	}{
		{config1, "eu-west-1", []ARN{{TargetID{"1", "webhook"}, "eu-west-1"}}},
		{config1, "", []ARN{{TargetID{"1", "webhook"}, ""}}},
		{config2, "us-east-1", []ARN{{TargetID{"1", "webhook"}, "us-east-1"}}},
		{config2, "", []ARN{{TargetID{"1", "webhook"}, ""}}},
		{config3, "us-east-1", []ARN{{TargetID{"1", "webhook"}, "us-east-1"}, {TargetID{"2", "amqp"}, "us-east-1"}}},

			Sensitive:   true,
		},
		config.HelpKV{
			Key:         BatchSize,
			Description: "Number of events per HTTP send to webhook target",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         QueueSize,
			Description: "configure channel queue size for webhook targets",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         QueueDir,

	quitCh chan struct{}
}

// ID - returns target ID.
func (target *MySQLTarget) ID() event.TargetID {
	return target.id
}

// Name - returns the Name of the target.
func (target *MySQLTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *MySQLTarget) Store() event.TargetStore {
	return target.store
}

}

func (target *NATSTarget) isActive() (bool, error) {
	var connErr error
	if target.args.Streaming.Enable {
		if target.stanConn == nil || target.stanConn.NatsConn() == nil {
			target.stanConn, connErr = target.args.connectStan()
		} else if !target.stanConn.NatsConn().IsConnected() {
			return false, store.ErrNotConnected
		}
	} else {
		if target.natsConn == nil {

  @Override
  int indexOf(@Nullable Object target) {
    if (!contains(target)) {
      return -1;
    }
    // The cast is safe because of the contains check—at least for any reasonable Comparable class.
    @SuppressWarnings("unchecked")
    // requireNonNull is safe because of the contains check.
    C c = (C) requireNonNull(target);
    return (int) domain.distance(first(), c);
  }

  @Override

func SetLoggerHTTPAudit(scfg config.Config, k string, args http.Config) {
	if !args.Enabled {
		// Do not enable audit targets, if not enabled
		return
	}
	scfg[config.AuditWebhookSubSys][k] = config.KVS{
		config.KV{
			Key:   config.Enable,
			Value: config.EnableOn,
		},
		config.KV{
			Key:   Endpoint,
			Value: args.Endpoint.String(),
		},
		config.KV{
			Key:   AuthToken,