github.com/sirupsen/logrus v1.4.2: FieldKeyLevel

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify github.com/sirupsen/logrus.FieldKeyLevel in pkg:golang/github.com/sirupsen/logrus@v1.4.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/sirupsen/logrus@v1.4.2
Demonstrate these symbols/APIs:
  - github.com/sirupsen/logrus.FieldKeyLevel

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:1e86968d1ea430cb0bc3610ffd60a90086738171a4260bb4184248698c287604","contract":["logrus.FieldKeyLevel equals \"level\" as the default key constant for log level","logrus.FieldKeyLevel configured in JSONFormatter FieldMap overrides the JSON level field key name","logrus.FieldKeyLevel configured in TextFormatter FieldMap overrides the text level field key name","logrus.FieldKeyLevel collision with custom field data is prefixed to avoid collision"],"goal":"verify github.com/sirupsen/logrus.FieldKeyLevel in pkg:golang/github.com/sirupsen/logrus@v1.4.2","kind":"HOW","packages":["pkg:golang/github.com/sirupsen/logrus@v1.4.2"],"schemaVersion":1,"symbols":["github.com/sirupsen/logrus.FieldKeyLevel"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/sirupsen/logrus@v1.4.2"],"schemaVersion":1,"subject":"pkg:golang/github.com/sirupsen/logrus@v1.4.2","symbols":["github.com/sirupsen/logrus.FieldKeyLevel"],"verifierAdapter":"golang@1"}

package sample

import (
	"bytes"

	"github.com/sirupsen/logrus"
)

// DefaultLevelKey returns the default key constant for the log level field.
func DefaultLevelKey() string {
	return logrus.FieldKeyLevel
}

// FormatJSONWithCustomLevelKey formats a message using JSONFormatter with FieldKeyLevel mapped to customKey.
func FormatJSONWithCustomLevelKey(customKey string, level logrus.Level, msg string) (string, error) {
	var buf bytes.Buffer
	logger := logrus.New()
	logger.SetOutput(&buf)
	logger.SetLevel(level)
	logger.SetFormatter(&logrus.JSONFormatter{
		DisableTimestamp: true,
		FieldMap: logrus.FieldMap{
			logrus.FieldKeyLevel: customKey,
		},
	})
	logger.Log(level, msg)
	return buf.String(), nil
}

// FormatTextWithCustomLevelKey formats a message using TextFormatter with FieldKeyLevel mapped to customKey.
func FormatTextWithCustomLevelKey(customKey string, level logrus.Level, msg string) (string, error) {
	var buf bytes.Buffer
	logger := logrus.New()
	logger.SetOutput(&buf)
	logger.SetLevel(level)
	logger.SetFormatter(&logrus.TextFormatter{
		DisableColors:    true,
		DisableTimestamp: true,
		FieldMap: logrus.FieldMap{
			logrus.FieldKeyLevel: customKey,
		},
	})
	logger.Log(level, msg)
	return buf.String(), nil
}

// FormatJSONWithCollision logs a message with a custom user field that matches the level key name.
func FormatJSONWithCollision(customKey string, userVal interface{}, msg string) (string, error) {
	var buf bytes.Buffer
	logger := logrus.New()
	logger.SetOutput(&buf)
	fieldMap := logrus.FieldMap{}
	if customKey != "" {
		fieldMap[logrus.FieldKeyLevel] = customKey
	}
	logger.SetFormatter(&logrus.JSONFormatter{
		DisableTimestamp: true,
		FieldMap:         fieldMap,
	})
	targetKey := logrus.FieldKeyLevel
	if customKey != "" {
		targetKey = customKey
	}
	logger.WithField(targetKey, userVal).Info(msg)
	return buf.String(), nil
}

module sample

go 1.26.6

require github.com/sirupsen/logrus v1.4.2

require (
	github.com/konsorten/go-windows-terminal-sequences v1.0.1 // indirect
	golang.org/x/sys v0.0.0-20190422165155-953cdadca894 // indirect
)

github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

{
  "schemaVersion": 1,
  "goal": "verify github.com/sirupsen/logrus.FieldKeyLevel in pkg:golang/github.com/sirupsen/logrus@v1.4.2",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/sirupsen/logrus@v1.4.2"
  ],
  "symbols": [
    "github.com/sirupsen/logrus.FieldKeyLevel"
  ]
}

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"github.com/sirupsen/logrus"
	"sample"
)

func main() {
	fmt.Println("Running contract tests for github.com/sirupsen/logrus.FieldKeyLevel...")

	// Assertion 1: logrus.FieldKeyLevel equals "level" as the default key constant for log level
	{
		if logrus.FieldKeyLevel != "level" {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: expected 'level', got %q\n", logrus.FieldKeyLevel)
			os.Exit(1)
		}
		if sample.DefaultLevelKey() != "level" {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: sample.DefaultLevelKey mismatch: %q\n", sample.DefaultLevelKey())
			os.Exit(1)
		}
		fmt.Println("  ✓ Assertion 1 passed: logrus.FieldKeyLevel equals 'level'")
	}

	// Assertion 2: logrus.FieldKeyLevel configured in JSONFormatter FieldMap overrides the JSON level field key name
	{
		customKey := "@level"
		out, err := sample.FormatJSONWithCustomLevelKey(customKey, logrus.WarnLevel, "contract test warning")
		if err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: %v\n", err)
			os.Exit(1)
		}

		var parsed map[string]interface{}
		if err := json.Unmarshal([]byte(out), &parsed); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed to parse JSON: %v\n", err)
			os.Exit(1)
		}

		if _, exists := parsed["level"]; exists {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: default 'level' key should not be present\n")
			os.Exit(1)
		}
		if parsed[customKey] != "warning" {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: expected %q = 'warning', got %v\n", customKey, parsed[customKey])
			os.Exit(1)
		}
		if parsed["msg"] != "contract test warning" {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: msg mismatch: %v\n", parsed["msg"])
			os.Exit(1)
		}
		fmt.Println("  ✓ Assertion 2 passed: JSONFormatter FieldMap overrides level key name")
	}

	// Assertion 3: logrus.FieldKeyLevel configured in TextFormatter FieldMap overrides the text level field key name
	{
		customKey := "severity"
		out, err := sample.FormatTextWithCustomLevelKey(customKey, logrus.ErrorLevel, "contract test error")
		if err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: %v\n", err)
			os.Exit(1)
		}

		if strings.Contains(out, "level=error") {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: default 'level=error' should not be present in output: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, "severity=error") {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: expected output to contain 'severity=error', got: %s\n", out)
			os.Exit(1)
		}
		if !strings.Contains(out, `msg="contract test error"`) {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: expected output to contain msg, got: %s\n", out)
			os.Exit(1)
		}
		fmt.Println("  ✓ Assertion 3 passed: TextFormatter FieldMap overrides text level field key name")
	}

	// Assertion 4: logrus.FieldKeyLevel collision with custom field data is prefixed to avoid collision
	{
		// Default level key collision
		out, err := sample.FormatJSONWithCollision("", "user-provided-level", "collision test message")
		if err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: %v\n", err)
			os.Exit(1)
		}

		var parsed map[string]interface{}
		if err := json.Unmarshal([]byte(out), &parsed); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed to parse JSON: %v\n", err)
			os.Exit(1)
		}

		if parsed["level"] != "info" {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: level should be 'info', got %v\n", parsed["level"])
			os.Exit(1)
		}
		if parsed["fields.level"] != "user-provided-level" {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: fields.level should be 'user-provided-level', got %v\n", parsed["fields.level"])
			os.Exit(1)
		}

		// Custom level key collision
		outCustom, err := sample.FormatJSONWithCollision("log_level", "custom-user-val", "custom collision test")
		if err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed with custom key: %v\n", err)
			os.Exit(1)
		}

		var parsedCustom map[string]interface{}
		if err := json.Unmarshal([]byte(outCustom), &parsedCustom); err != nil {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed to parse custom JSON: %v\n", err)
			os.Exit(1)
		}

		if parsedCustom["log_level"] != "info" {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: log_level should be 'info', got %v\n", parsedCustom["log_level"])
			os.Exit(1)
		}
		if parsedCustom["fields.log_level"] != "custom-user-val" {
			fmt.Fprintf(os.Stderr, "Assertion 4 failed: fields.log_level should be 'custom-user-val', got %v\n", parsedCustom["fields.log_level"])
			os.Exit(1)
		}

		fmt.Println("  ✓ Assertion 4 passed: level field collisions are prefixed to avoid clashing")
	}

	fmt.Println("PASS: all logrus.FieldKeyLevel contract assertions passed.")
}