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

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.ErrorLevel 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.ErrorLevel

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:00990f8aafe7e2cbaeb3da005308c4370abbf4bac1364b6f7b050ffb54ccade7","contract":["logrus.ErrorLevel has string representation error and is parsed from string by logrus.ParseLevel","Logger configured at logrus.ErrorLevel enables PanicLevel, FatalLevel, and ErrorLevel while filtering out WarnLevel, InfoLevel, DebugLevel, and TraceLevel","Logger configured at logrus.ErrorLevel emits Error messages to destination writer and suppresses Warn, Info, and Debug messages"],"goal":"verify github.com/sirupsen/logrus.ErrorLevel 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.ErrorLevel"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","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.ErrorLevel"],"verifierAdapter":"golang@1"}

package sample

import (
	"bytes"

	"github.com/sirupsen/logrus"
)

// ErrorLevelConstant returns the logrus.ErrorLevel constant.
func ErrorLevelConstant() logrus.Level {
	return logrus.ErrorLevel
}

// ErrorLevelString returns the string representation of logrus.ErrorLevel.
func ErrorLevelString() string {
	return logrus.ErrorLevel.String()
}

// ParseErrorLevel parses a string into logrus.Level.
func ParseErrorLevel(s string) (logrus.Level, error) {
	return logrus.ParseLevel(s)
}

// ErrorFilterLogger encapsulates a logrus.Logger configured at logrus.ErrorLevel and an output buffer.
type ErrorFilterLogger struct {
	Logger *logrus.Logger
	Buffer *bytes.Buffer
}

// NewErrorFilterLogger creates a logger set to ErrorLevel writing to an internal buffer.
func NewErrorFilterLogger() *ErrorFilterLogger {
	buf := &bytes.Buffer{}
	logger := logrus.New()
	logger.SetOutput(buf)
	logger.SetLevel(logrus.ErrorLevel)
	logger.SetFormatter(&logrus.JSONFormatter{
		DisableTimestamp: true,
	})
	return &ErrorFilterLogger{
		Logger: logger,
		Buffer: buf,
	}
}

// IsEnabled checks if the given level is enabled on the logger.
func (l *ErrorFilterLogger) IsEnabled(level logrus.Level) bool {
	return l.Logger.IsLevelEnabled(level)
}

// LogEvents logs debug, info, warn, and error messages to demonstrate level filtering.
func (l *ErrorFilterLogger) LogEvents(debugMsg, infoMsg, warnMsg, errorMsg string) {
	l.Logger.Debug(debugMsg)
	l.Logger.Info(infoMsg)
	l.Logger.Warn(warnMsg)
	l.Logger.Error(errorMsg)
}

module sample

go 1.22

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.ErrorLevel 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.ErrorLevel"
  ]
}

package main

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

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

type logEntry struct {
	Level string `json:"level"`
	Msg   string `json:"msg"`
}

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

	// Assertion 1: logrus.ErrorLevel has string representation error and is parsed from string by logrus.ParseLevel
	{
		if sample.ErrorLevelConstant() != logrus.ErrorLevel {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: expected ErrorLevel %v, got %v\n", logrus.ErrorLevel, sample.ErrorLevelConstant())
			os.Exit(1)
		}
		if sample.ErrorLevelString() != "error" {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: expected string 'error', got %q\n", sample.ErrorLevelString())
			os.Exit(1)
		}
		parsedError, err := sample.ParseErrorLevel("error")
		if err != nil || parsedError != logrus.ErrorLevel {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: ParseErrorLevel('error') error: %v, got %v\n", err, parsedError)
			os.Exit(1)
		}
		parsedUpper, err := sample.ParseErrorLevel("ERROR")
		if err != nil || parsedUpper != logrus.ErrorLevel {
			fmt.Fprintf(os.Stderr, "Assertion 1 failed: ParseErrorLevel('ERROR') error: %v, got %v\n", err, parsedUpper)
			os.Exit(1)
		}
		fmt.Println("  ✓ Assertion 1 passed: logrus.ErrorLevel string representation and parsing verified")
	}

	// Assertion 2: Logger configured at logrus.ErrorLevel enables PanicLevel, FatalLevel, and ErrorLevel while filtering out WarnLevel, InfoLevel, DebugLevel, and TraceLevel
	{
		l := sample.NewErrorFilterLogger()
		if !l.IsEnabled(logrus.PanicLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: PanicLevel should be enabled\n")
			os.Exit(1)
		}
		if !l.IsEnabled(logrus.FatalLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: FatalLevel should be enabled\n")
			os.Exit(1)
		}
		if !l.IsEnabled(logrus.ErrorLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: ErrorLevel should be enabled\n")
			os.Exit(1)
		}
		if l.IsEnabled(logrus.WarnLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: WarnLevel should be disabled\n")
			os.Exit(1)
		}
		if l.IsEnabled(logrus.InfoLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: InfoLevel should be disabled\n")
			os.Exit(1)
		}
		if l.IsEnabled(logrus.DebugLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: DebugLevel should be disabled\n")
			os.Exit(1)
		}
		if l.IsEnabled(logrus.TraceLevel) {
			fmt.Fprintf(os.Stderr, "Assertion 2 failed: TraceLevel should be disabled\n")
			os.Exit(1)
		}
		fmt.Println("  ✓ Assertion 2 passed: Level hierarchy enabling logic verified for ErrorLevel")
	}

	// Assertion 3: Logger configured at logrus.ErrorLevel emits Error messages to destination writer and suppresses Warn, Info, and Debug messages
	{
		l := sample.NewErrorFilterLogger()
		l.LogEvents("debug message should be suppressed", "info message should be suppressed", "warn message should be suppressed", "error message error event")

		var entries []logEntry
		decoder := json.NewDecoder(l.Buffer)
		for decoder.More() {
			var entry logEntry
			if err := decoder.Decode(&entry); err != nil {
				fmt.Fprintf(os.Stderr, "Assertion 3 failed to decode log entry: %v\n", err)
				os.Exit(1)
			}
			entries = append(entries, entry)
		}

		if len(entries) != 1 {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: expected 1 entry, got %d (raw: %s)\n", len(entries), l.Buffer.String())
			os.Exit(1)
		}
		if entries[0].Level != "error" || entries[0].Msg != "error message error event" {
			fmt.Fprintf(os.Stderr, "Assertion 3 failed: unexpected entry 0: %+v\n", entries[0])
			os.Exit(1)
		}
		fmt.Println("  ✓ Assertion 3 passed: ErrorLevel emission and lower-level suppression verified")
	}

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