logger

func (*CLEFSink) Log(e Entry) error
{
	// Build a flat map so structured fields sit at the root level.
	m := make(map[string]any, len(e.Fields)+3)
	for k, v := range e.Fields {
		m[k] = v
	}

	m["@t"] = e.Time.UTC().Format(time.RFC3339Nano)
	m["@m"] = e.Msg

	// @l is omitted for Information per the CLEF spec.
	if lvl, ok := clefLevel[e.Level]; ok {
		m["@l"] = lvl
	}

	b, err := json.Marshal(m)
	if err != nil {
		return err
	}
	_, err = c.w.Write(append(b, '\n'))
	return err
}

func (*stdLogger) With(fields ...Field) Logger
{
	l.mu.RLock()
	defer l.mu.RUnlock()

	nextFields := make(map[string]interface{}, len(l.fields)+len(fields))
	for k, v := range l.fields {
		nextFields[k] = v
	}
	for _, f := range fields {
		nextFields[f.Key] = f.Value
	}

	return &stdLogger{
		sinks:  l.sinks,
		level:  l.level,
		fields: nextFields,
	}
}

func (*stdLogger) log(level Level, msg string, fields ...Field)
{
	if !l.shouldLog(level) {
		return
	}

	entry := Entry{
		Level:  level.String(),
		Time:   time.Now().UTC(),
		Msg:    msg,
		Fields: map[string]interface{}{},
	}

	l.mu.RLock()
	for k, v := range l.fields {
		entry.Fields[k] = v
	}
	sinks := append([]Sink(nil), l.sinks...)
	l.mu.RUnlock()

	for _, f := range fields {
		entry.Fields[f.Key] = f.Value
	}

	for _, sink := range sinks {
		_ = sink.Log(entry)
	}
}

func (*PrometheusSink) Handler() http.Handler
{
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		p.mu.Lock()
		defer p.mu.Unlock()

		w.Header().Set("Content-Type", "text/plain; version=0.0.4")
		for level, value := range p.counters {
			_, _ = fmt.Fprintf(w, "go_logger_logs_total{level=\"%s\"} %d\n", level, value)
		}
	})
}

func (*TelegramSink) Log(e Entry) error
{
	if levelFromString(e.Level) < t.minLevel {
		return nil
	}

	fields, err := json.Marshal(e.Fields)
	if err != nil {
		return err
	}

	var body bytes.Buffer
	body.WriteString("[")
	body.WriteString(e.Level)
	body.WriteString("] ")
	body.WriteString(e.Msg)
	body.WriteString("\ntime: ")
	body.WriteString(e.Time.Format(time.RFC3339))
	if len(fields) > 0 {
		body.WriteString("\nfields: ")
		body.Write(fields)
	}

	apiURL := "https://api.telegram.org/bot" + url.PathEscape(t.botToken) + "/sendMessage"
	form := url.Values{}
	form.Set("chat_id", t.chatID)
	form.Set("text", body.String())

	resp, err := t.client.PostForm(apiURL, form)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		return fmt.Errorf("telegram sink: unexpected status %d", resp.StatusCode)
	}
	return nil
}