var l string
	if anonFlag {
		l = reflect.TypeOf(err).String()
	} else {
		l = fmt.Sprintf("%v (%T)", err, err)
	}
	return buildLogEntry(ctx, subsystem, l, getTrace(3), errKind...)
}

func logToEntry(ctx context.Context, subsystem, message string, errKind ...interface{}) log.Entry {
	return buildLogEntry(ctx, subsystem, message, nil, errKind...)
}

	logger.LogIf(ctx, "bootstrap", err, errKind...)
}

func bootLogOnceIf(ctx context.Context, err error, id string, errKind ...interface{}) {
	logger.LogOnceIf(ctx, "bootstrap", err, id, errKind...)
}

func dnsLogIf(ctx context.Context, err error, errKind ...interface{}) {
	logger.LogIf(ctx, "dns", err, errKind...)
}

func internalLogIf(ctx context.Context, err error, errKind ...interface{}) {

func LogOnceIf(ctx context.Context, subsystem string, err error, id string, errKind ...interface{}) {
	if logIgnoreError(err) {
		return
	}
	logOnce.logOnceIf(ctx, subsystem, err, id, errKind...)
}

// LogOnceConsoleIf - similar to LogOnceIf but exclusively only logs to console target.
func LogOnceConsoleIf(ctx context.Context, subsystem string, err error, id string, errKind ...interface{}) {
	if logIgnoreError(err) {
		return
	}

	"github.com/minio/pkg/v2/env"
	xnet "github.com/minio/pkg/v2/net"
)

const (
	logSubsys = "notify"
)

func logOnceIf(ctx context.Context, err error, id string, errKind ...interface{}) {
	logger.LogOnceIf(ctx, logSubsys, err, id, errKind...)
}

// ErrTargetsOffline - Indicates single/multiple target failures.

	"errors"
	"fmt"
	"strings"
	"time"

	xioutil "github.com/minio/minio/internal/ioutil"
)

const (
	retryInterval = 3 * time.Second
)

type logger = func(ctx context.Context, err error, id string, errKind ...interface{})

// ErrNotConnected - indicates that the target connection is not active.
var ErrNotConnected = errors.New("not connected to target server/service")

// Target - store target interface

	} else {
		cfg.inlineBlock = 128 * humanize.KiByte
	}

	cfg.initialized = true

	return cfg, nil
}

func configLogOnceIf(ctx context.Context, err error, id string, errKind ...interface{}) {
	logger.LogOnceIf(ctx, "config", err, id, errKind...)

	return results
}

// Logger interface permits access to module specific logging, in this case, for KMS
type Logger interface {
	LogOnceIf(ctx context.Context, err error, id string, errKind ...interface{})
	LogIf(ctx context.Context, err error, errKind ...interface{})
}

// RefreshKey checks the validity of the KMS Master Key
func (c *kesClient) RefreshKey(ctx context.Context, logger Logger) bool {
	c.lock.RLock()

)

func gridLogIf(ctx context.Context, err error, errKind ...interface{}) {
	logger.LogIf(ctx, "grid", err, errKind...)
}

func gridLogIfNot(ctx context.Context, err error, ignored ...error) {
	logger.LogIfNot(ctx, "grid", err, ignored...)
}

func gridLogOnceIf(ctx context.Context, err error, id string, errKind ...interface{}) {
	logger.LogOnceIf(ctx, "grid", err, id, errKind...)
}

// A Connection is a remote connection.

	} `json:"sasl"`
	// Queue store
	QueueSize int    `json:"queueSize"`
	QueueDir  string `json:"queueDir"`

	// Custom logger
	LogOnce func(ctx context.Context, err error, id string, errKind ...interface{}) `json:"-"`
}

// Target - Kafka target.
type Target struct {
	status int32

	totalMessages  int64
	failedMessages int64

	wg sync.WaitGroup

	// Channel of log entries.

	QueueDir   string            `json:"queueDir"`
	Proxy      string            `json:"string"`
	Transport  http.RoundTripper `json:"-"`

	// Custom logger
	LogOnceIf func(ctx context.Context, err error, id string, errKind ...interface{}) `json:"-"`
}

// Target implements logger.Target and sends the json
// format of a log entry to the configured http endpoint.
// An internal buffer of logs is maintained but when the