xoptestutil

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 23, 2024 License: MIT Imports: 22 Imported by: 0

Documentation

Index

Constants

View Source 
const NeedsEscaping = `"\<'` + "\n\r\t\b\x00"

Variables

View Source 
var (
	ExampleMetadataSingleAny   = xopat.Make{Key: "s-any", Namespace: "test"}.AnyAttribute(AnyObject{})
	ExampleMetadataLockedAny   = xopat.Make{Key: "l-any", Locked: true, Namespace: "test"}.AnyAttribute(AnyObject{})
	ExampleMetadataMultipleAny = xopat.Make{Key: "m-any", Multiple: true, Namespace: "test"}.AnyAttribute(AnyObject{})
	ExampleMetadataDistinctAny = xopat.Make{Key: "d-any", Multiple: true, Distinct: true, Namespace: "test"}.AnyAttribute(AnyObject{})
)
View Source 
var (
	ExampleMetadataSingleEnum   = xopat.Make{Key: "s-ienum", Namespace: "test"}.IotaEnumAttribute()
	ExampleMetadataLockedEnum   = xopat.Make{Key: "l-ienum", Locked: true, Namespace: "test"}.IotaEnumAttribute()
	ExampleMetadataMultipleEnum = xopat.Make{Key: "m-ienum", Multiple: true, Namespace: "test"}.IotaEnumAttribute()
	ExampleMetadataDistinctEnum = xopat.Make{Key: "d-ienum", Multiple: true, Distinct: true, Namespace: "test"}.IotaEnumAttribute()
)
View Source 
var (
	SingleEnumOne   = ExampleMetadataSingleEnum.Iota("one")
	SingleEnumTwo   = ExampleMetadataSingleEnum.Iota("two")
	SingleEnumThree = ExampleMetadataSingleEnum.Iota("Three")

	LockedEnumOne   = ExampleMetadataLockedEnum.Iota("one")
	LockedEnumTwo   = ExampleMetadataLockedEnum.Iota("two")
	LockedEnumThree = ExampleMetadataLockedEnum.Iota("Three")

	MultipleEnumOne   = ExampleMetadataMultipleEnum.Iota("one")
	MultipleEnumTwo   = ExampleMetadataMultipleEnum.Iota("two")
	MultipleEnumThree = ExampleMetadataMultipleEnum.Iota("Three")

	DistinctEnumOne   = ExampleMetadataDistinctEnum.Iota("one")
	DistinctEnumTwo   = ExampleMetadataDistinctEnum.Iota("two")
	DistinctEnumThree = ExampleMetadataDistinctEnum.Iota("Three")
)
View Source 
var (
	ExampleMetadataSingleEEnum   = xopat.Make{Key: "s-eenum", Namespace: "test"}.EmbeddedEnumAttribute(threeType(1))
	ExampleMetadataLockedEEnum   = xopat.Make{Key: "l-eenum", Locked: true, Namespace: "test"}.EmbeddedEnumAttribute(1)
	ExampleMetadataMultipleEEnum = xopat.Make{Key: "m-eenum", Multiple: true, Namespace: "test"}.EmbeddedEnumAttribute(int64(1))
	ExampleMetadataDistinctEEnum = xopat.Make{Key: "d-eenum", Multiple: true, Distinct: true, Namespace: "test"}.EmbeddedEnumAttribute(threeType(1))
)
View Source 
var (
	SingleEEnumOne   = ExampleMetadataSingleEEnum.AddStringer(threeType(1))
	SingleEEnumTwo   = ExampleMetadataSingleEEnum.AddStringer(threeType(2))
	SingleEEnumThree = ExampleMetadataSingleEEnum.AddStringer(threeType(3))

	LockedEEnumOne   = ExampleMetadataLockedEEnum.Add(1, "one")
	LockedEEnumTwo   = ExampleMetadataLockedEEnum.Add(2, "two")
	LockedEEnumThree = ExampleMetadataLockedEEnum.Add(3, "three")

	MultipleEEnumOne   = ExampleMetadataMultipleEEnum.Add64(int64(1), "one")
	MultipleEEnumTwo   = ExampleMetadataMultipleEEnum.Add64(int64(2), "two")
	MultipleEEnumThree = ExampleMetadataMultipleEEnum.Add64(int64(3), "three")

	DistinctEEnumOne   = ExampleMetadataDistinctEEnum.AddStringer(threeType(1))
	DistinctEEnumTwo   = ExampleMetadataDistinctEEnum.AddStringer(threeType(2))
	DistinctEEnumThree = ExampleMetadataDistinctEEnum.AddStringer(threeType(3))
)
View Source 
var (
	ExampleMetadataSingleXEnum   = xopat.Make{Key: "s-xenum", Namespace: "test"}.EnumAttribute(xopconst.SpanKindServer)
	ExampleMetadataLockedXEnum   = xopat.Make{Key: "l-xenum", Locked: true, Namespace: "test"}.EnumAttribute(xopconst.SpanKindServer)
	ExampleMetadataMultipleXEnum = xopat.Make{Key: "m-xenum", Multiple: true, Namespace: "test"}.EnumAttribute(xopconst.SpanKindServer)
	ExampleMetadataDistinctXEnum = xopat.Make{Key: "d-xenum", Multiple: true, Distinct: true, Namespace: "test"}.EnumAttribute(xopconst.SpanKindServer)
)
View Source 
var (
	ExampleMetadataSingleBool       = xopat.Make{Key: "s-bool", Namespace: "test"}.BoolAttribute()
	ExampleMetadataLockedBool       = xopat.Make{Key: "l-bool", Locked: true, Namespace: "test"}.BoolAttribute()
	ExampleMetadataMultipleBool     = xopat.Make{Key: "m-bool", Multiple: true, Namespace: "test"}.BoolAttribute()
	ExampleMetadataDistinctBool     = xopat.Make{Key: "d-bool", Multiple: true, Distinct: true, Namespace: "test"}.BoolAttribute()
	ExampleMetadataSingleDuration   = xopat.Make{Key: "s-time.Duration", Namespace: "test"}.DurationAttribute()
	ExampleMetadataLockedDuration   = xopat.Make{Key: "l-time.Duration", Locked: true, Namespace: "test"}.DurationAttribute()
	ExampleMetadataMultipleDuration = xopat.Make{Key: "m-time.Duration", Multiple: true, Namespace: "test"}.DurationAttribute()
	ExampleMetadataDistinctDuration = xopat.Make{Key: "d-time.Duration", Multiple: true, Distinct: true, Namespace: "test"}.DurationAttribute()
	ExampleMetadataSingleFloat64    = xopat.Make{Key: "s-float64", Namespace: "test"}.Float64Attribute()
	ExampleMetadataLockedFloat64    = xopat.Make{Key: "l-float64", Locked: true, Namespace: "test"}.Float64Attribute()
	ExampleMetadataMultipleFloat64  = xopat.Make{Key: "m-float64", Multiple: true, Namespace: "test"}.Float64Attribute()
	ExampleMetadataDistinctFloat64  = xopat.Make{Key: "d-float64", Multiple: true, Distinct: true, Namespace: "test"}.Float64Attribute()
	ExampleMetadataSingleInt        = xopat.Make{Key: "s-int", Namespace: "test"}.IntAttribute()
	ExampleMetadataLockedInt        = xopat.Make{Key: "l-int", Locked: true, Namespace: "test"}.IntAttribute()
	ExampleMetadataMultipleInt      = xopat.Make{Key: "m-int", Multiple: true, Namespace: "test"}.IntAttribute()
	ExampleMetadataDistinctInt      = xopat.Make{Key: "d-int", Multiple: true, Distinct: true, Namespace: "test"}.IntAttribute()
	ExampleMetadataSingleInt16      = xopat.Make{Key: "s-int16", Namespace: "test"}.Int16Attribute()
	ExampleMetadataLockedInt16      = xopat.Make{Key: "l-int16", Locked: true, Namespace: "test"}.Int16Attribute()
	ExampleMetadataMultipleInt16    = xopat.Make{Key: "m-int16", Multiple: true, Namespace: "test"}.Int16Attribute()
	ExampleMetadataDistinctInt16    = xopat.Make{Key: "d-int16", Multiple: true, Distinct: true, Namespace: "test"}.Int16Attribute()
	ExampleMetadataSingleInt32      = xopat.Make{Key: "s-int32", Namespace: "test"}.Int32Attribute()
	ExampleMetadataLockedInt32      = xopat.Make{Key: "l-int32", Locked: true, Namespace: "test"}.Int32Attribute()
	ExampleMetadataMultipleInt32    = xopat.Make{Key: "m-int32", Multiple: true, Namespace: "test"}.Int32Attribute()
	ExampleMetadataDistinctInt32    = xopat.Make{Key: "d-int32", Multiple: true, Distinct: true, Namespace: "test"}.Int32Attribute()
	ExampleMetadataSingleInt64      = xopat.Make{Key: "s-int64", Namespace: "test"}.Int64Attribute()
	ExampleMetadataLockedInt64      = xopat.Make{Key: "l-int64", Locked: true, Namespace: "test"}.Int64Attribute()
	ExampleMetadataMultipleInt64    = xopat.Make{Key: "m-int64", Multiple: true, Namespace: "test"}.Int64Attribute()
	ExampleMetadataDistinctInt64    = xopat.Make{Key: "d-int64", Multiple: true, Distinct: true, Namespace: "test"}.Int64Attribute()
	ExampleMetadataSingleInt8       = xopat.Make{Key: "s-int8", Namespace: "test"}.Int8Attribute()
	ExampleMetadataLockedInt8       = xopat.Make{Key: "l-int8", Locked: true, Namespace: "test"}.Int8Attribute()
	ExampleMetadataMultipleInt8     = xopat.Make{Key: "m-int8", Multiple: true, Namespace: "test"}.Int8Attribute()
	ExampleMetadataDistinctInt8     = xopat.Make{Key: "d-int8", Multiple: true, Distinct: true, Namespace: "test"}.Int8Attribute()
	ExampleMetadataSingleLink       = xopat.Make{Key: "s-xoptrace.Trace", Namespace: "test"}.LinkAttribute()
	ExampleMetadataLockedLink       = xopat.Make{Key: "l-xoptrace.Trace", Locked: true, Namespace: "test"}.LinkAttribute()
	ExampleMetadataMultipleLink     = xopat.Make{Key: "m-xoptrace.Trace", Multiple: true, Namespace: "test"}.LinkAttribute()
	ExampleMetadataDistinctLink     = xopat.Make{Key: "d-xoptrace.Trace", Multiple: true, Distinct: true, Namespace: "test"}.LinkAttribute()
	ExampleMetadataSingleString     = xopat.Make{Key: "s-string", Namespace: "test"}.StringAttribute()
	ExampleMetadataLockedString     = xopat.Make{Key: "l-string", Locked: true, Namespace: "test"}.StringAttribute()
	ExampleMetadataMultipleString   = xopat.Make{Key: "m-string", Multiple: true, Namespace: "test"}.StringAttribute()
	ExampleMetadataDistinctString   = xopat.Make{Key: "d-string", Multiple: true, Distinct: true, Namespace: "test"}.StringAttribute()
	ExampleMetadataSingleTime       = xopat.Make{Key: "s-time.Time", Namespace: "test"}.TimeAttribute()
	ExampleMetadataLockedTime       = xopat.Make{Key: "l-time.Time", Locked: true, Namespace: "test"}.TimeAttribute()
	ExampleMetadataMultipleTime     = xopat.Make{Key: "m-time.Time", Multiple: true, Namespace: "test"}.TimeAttribute()
	ExampleMetadataDistinctTime     = xopat.Make{Key: "d-time.Time", Multiple: true, Distinct: true, Namespace: "test"}.TimeAttribute()
)
View Source 
var MessageCases = []struct {
	Name         string
	ExtraFlushes int
	Do           func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger)
	SkipOTEL     bool
	SeedMods     []xop.SeedModifier
}{
	{
		Name: "one-span",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			log.Info().Msg("basic info message")
			log.Error().Msg("basic error message")
			log.Alert().Msg("basic alert message")
			log.Debug().Msg("basic debug message")
			log.Trace().Msg("basic trace message")
			log.Info().String(xop.Key("foo"), "bar").Int(xop.Key("num"), 38).Template("a test {foo} with {num}")

			ss := log.Sub().Detach().Fork("a fork one span")
			MicroNap()
			ss.Alert().String(xop.Key("frightening"), "stuff").Msg("like a rock" + NeedsEscaping)
			ss.Span().String(xopconst.EndpointRoute, "/some/thing")

			MicroNap()
			tlog.CustomEvent("before log.Done")
			log.Done()
			tlog.CustomEvent("after log.Done")
			ss.Debug().Msg("sub-span debug message")
			MicroNap()
			tlog.CustomEvent("before ss.Done")
			ss.Done()
			tlog.CustomEvent("after ss.Done")
		},
	},
	{
		Name: "metadata-singles-in-request",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			log.Span().Bool(ExampleMetadataSingleBool, false)
			log.Span().Bool(ExampleMetadataSingleBool, true)
			log.Span().Bool(ExampleMetadataLockedBool, true)
			log.Span().Bool(ExampleMetadataLockedBool, false)
			log.Span().String(ExampleMetadataLockedString, "loki"+NeedsEscaping)
			log.Span().String(ExampleMetadataLockedString, "thor"+NeedsEscaping)
			log.Span().Int(ExampleMetadataLockedInt, 38)
			log.Span().Int(ExampleMetadataLockedInt, -38)
			log.Span().Int8(ExampleMetadataLockedInt8, 39)
			log.Span().Int8(ExampleMetadataLockedInt8, -39)
			log.Span().Int16(ExampleMetadataLockedInt16, 329)
			log.Span().Int16(ExampleMetadataLockedInt16, -329)
			log.Span().Int32(ExampleMetadataLockedInt32, -932)
			log.Span().Int32(ExampleMetadataLockedInt32, 932)
			log.Span().Int64(ExampleMetadataLockedInt64, -93232)
			log.Span().Int64(ExampleMetadataLockedInt64, 93232)
			log.Span().String(ExampleMetadataSingleString, "athena")
			log.Span().Int(ExampleMetadataSingleInt, 3)
			log.Span().Int8(ExampleMetadataSingleInt8, 9)
			log.Span().Int16(ExampleMetadataSingleInt16, 29)
			log.Span().Int32(ExampleMetadataSingleInt32, -32)
			log.Span().Int64(ExampleMetadataSingleInt64, -3232)
			log.Span().Duration(ExampleMetadataSingleDuration, 3*time.Second)
			MicroNap()
			log.Done()
		},
	},
	{
		Name:     "metadata-traces",
		SkipOTEL: true,
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			s2 := log.Sub().Fork("S2")
			s3 := s2.Sub().Fork("S3")
			log.Span().Link(ExampleMetadataSingleLink, s2.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataSingleLink, s3.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataLockedLink, s2.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataLockedLink, s3.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataMultipleLink, s2.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataMultipleLink, s3.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataMultipleLink, s3.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataDistinctLink, s2.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataDistinctLink, s3.Span().Bundle().Trace)
			log.Span().Link(ExampleMetadataDistinctLink, s3.Span().Bundle().Trace)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-float64",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			log.Span().Float64(ExampleMetadataSingleFloat64, 40.3)
			log.Span().Float64(ExampleMetadataSingleFloat64, 40.4)
			log.Span().Float64(ExampleMetadataLockedFloat64, 30.5)
			log.Span().Float64(ExampleMetadataLockedFloat64, 30.6)
			log.Span().Float64(ExampleMetadataMultipleFloat64, 10.7)
			log.Span().Float64(ExampleMetadataMultipleFloat64, 10.8)
			log.Span().Float64(ExampleMetadataMultipleFloat64, 10.7)
			log.Span().Float64(ExampleMetadataDistinctFloat64, 20.8)
			log.Span().Float64(ExampleMetadataDistinctFloat64, 20.7)
			log.Span().Float64(ExampleMetadataDistinctFloat64, 20.8)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-time",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			t1 := time.Now().Round(time.Second)
			t2 := t1.Add(time.Minute)
			log.Span().Time(ExampleMetadataSingleTime, t1)
			log.Span().Time(ExampleMetadataSingleTime, t2)
			log.Span().Time(ExampleMetadataLockedTime, t1)
			log.Span().Time(ExampleMetadataLockedTime, t2)
			log.Span().Time(ExampleMetadataMultipleTime, t1)
			log.Span().Time(ExampleMetadataMultipleTime, t2)
			log.Span().Time(ExampleMetadataMultipleTime, t2)
			log.Span().Time(ExampleMetadataDistinctTime, t1)
			log.Span().Time(ExampleMetadataDistinctTime, t2)
			log.Span().Time(ExampleMetadataDistinctTime, t2)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-duration",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			d1 := time.Millisecond
			d2 := time.Millisecond * 5
			log.Span().Duration(ExampleMetadataSingleDuration, d1)
			log.Span().Duration(ExampleMetadataSingleDuration, d2)
			log.Span().Duration(ExampleMetadataLockedDuration, d1)
			log.Span().Duration(ExampleMetadataLockedDuration, d2)
			log.Span().Duration(ExampleMetadataMultipleDuration, d1)
			log.Span().Duration(ExampleMetadataMultipleDuration, d2)
			log.Span().Duration(ExampleMetadataMultipleDuration, d2)
			log.Span().Duration(ExampleMetadataDistinctDuration, d1)
			log.Span().Duration(ExampleMetadataDistinctDuration, d2)
			log.Span().Duration(ExampleMetadataDistinctDuration, d2)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-singles-in-span",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			ss := log.Sub().Fork("spoon")
			ss.Span().Bool(ExampleMetadataSingleBool, false)
			ss.Span().Bool(ExampleMetadataSingleBool, true)
			ss.Span().Bool(ExampleMetadataLockedBool, true)
			ss.Span().Bool(ExampleMetadataLockedBool, false)
			ss.Span().String(ExampleMetadataLockedString, "loki")
			ss.Span().String(ExampleMetadataLockedString, "thor")
			ss.Span().Int(ExampleMetadataLockedInt, 38)
			ss.Span().Int(ExampleMetadataLockedInt, -38)
			ss.Span().Int8(ExampleMetadataLockedInt8, 39)
			ss.Span().Int8(ExampleMetadataLockedInt8, -39)
			ss.Span().Int16(ExampleMetadataLockedInt16, 329)
			ss.Span().Int16(ExampleMetadataLockedInt16, -329)
			ss.Span().Int32(ExampleMetadataLockedInt32, -932)
			ss.Span().Int32(ExampleMetadataLockedInt32, 932)
			ss.Span().Int64(ExampleMetadataLockedInt64, -93232)
			ss.Span().Int64(ExampleMetadataLockedInt64, 93232)
			ss.Span().String(ExampleMetadataSingleString, "athena"+NeedsEscaping)
			ss.Span().Int(ExampleMetadataSingleInt, 3)
			ss.Span().Int8(ExampleMetadataSingleInt8, 9)
			ss.Span().Int16(ExampleMetadataSingleInt16, 29)
			ss.Span().Int32(ExampleMetadataSingleInt32, -32)
			ss.Span().Int64(ExampleMetadataSingleInt64, -3232)
			ss.Span().Bool(ExampleMetadataSingleBool, false)
			ss.Span().Bool(ExampleMetadataSingleBool, true)
			ss.Span().Bool(ExampleMetadataLockedBool, true)
			ss.Span().Bool(ExampleMetadataLockedBool, false)
			ss.Span().String(ExampleMetadataLockedString, "loki")
			ss.Span().String(ExampleMetadataLockedString, "thor")
			ss.Span().Int(ExampleMetadataLockedInt, 38)
			ss.Span().Int(ExampleMetadataLockedInt, -38)
			ss.Span().Int8(ExampleMetadataLockedInt8, 39)
			ss.Span().Int8(ExampleMetadataLockedInt8, -39)
			ss.Span().Int16(ExampleMetadataLockedInt16, 329)
			ss.Span().Int16(ExampleMetadataLockedInt16, -329)
			ss.Span().Int32(ExampleMetadataLockedInt32, -932)
			ss.Span().Int32(ExampleMetadataLockedInt32, 932)
			ss.Span().Int64(ExampleMetadataLockedInt64, -93232)
			ss.Span().Int64(ExampleMetadataLockedInt64, 93232)
			ss.Span().String(ExampleMetadataSingleString, "athena")
			ss.Span().Int(ExampleMetadataSingleInt, 3)
			ss.Span().Int8(ExampleMetadataSingleInt8, 9)
			ss.Span().Int16(ExampleMetadataSingleInt16, 29)
			ss.Span().Int32(ExampleMetadataSingleInt32, -32)
			ss.Span().Int64(ExampleMetadataSingleInt64, -3232)
			ss.Span().Duration(ExampleMetadataSingleDuration, time.Millisecond)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-any",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			ss := log.Sub().Fork("knife")
			a := map[string]interface{}{
				"foo":   "bar",
				"count": 329,
				"array": []int{8, 22},
			}
			b := map[string]interface{}{
				"foo":   "baz",
				"count": 10,
				"array": []int{33, 39},
			}
			ss.Span().Any(ExampleMetadataSingleAny, a)
			ss.Span().Any(ExampleMetadataSingleAny, b)
			ss.Span().Any(ExampleMetadataLockedAny, a)
			ss.Span().Any(ExampleMetadataLockedAny, b)
			ss.Span().Any(ExampleMetadataMultipleAny, a)
			ss.Span().Any(ExampleMetadataMultipleAny, b)
			ss.Span().Any(ExampleMetadataDistinctAny, a)
			ss.Span().Any(ExampleMetadataDistinctAny, a)
			ss.Span().Any(ExampleMetadataDistinctAny, b)
			log.Span().Any(ExampleMetadataSingleAny, a)
			log.Span().Any(ExampleMetadataSingleAny, b)
			log.Span().Any(ExampleMetadataLockedAny, a)
			log.Span().Any(ExampleMetadataLockedAny, b)
			log.Span().Any(ExampleMetadataMultipleAny, a)
			log.Span().Any(ExampleMetadataMultipleAny, b)
			log.Span().Any(ExampleMetadataDistinctAny, a)
			log.Span().Any(ExampleMetadataDistinctAny, a)
			log.Span().Any(ExampleMetadataDistinctAny, b)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-iota-enum",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			ss := log.Sub().Step("stool")
			ss.Span().EmbeddedEnum(SingleEnumTwo)
			ss.Span().EmbeddedEnum(SingleEnumTwo)
			ss.Span().EmbeddedEnum(SingleEnumThree)
			ss.Span().EmbeddedEnum(LockedEnumTwo)
			ss.Span().EmbeddedEnum(LockedEnumTwo)
			ss.Span().EmbeddedEnum(LockedEnumThree)
			log.Span().EmbeddedEnum(MultipleEnumTwo)
			log.Span().EmbeddedEnum(MultipleEnumTwo)
			log.Span().EmbeddedEnum(MultipleEnumThree)
			log.Span().EmbeddedEnum(DistinctEnumTwo)
			log.Span().EmbeddedEnum(DistinctEnumTwo)
			log.Span().EmbeddedEnum(DistinctEnumThree)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-embedded-enum",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			ss := log.Sub().Step("stool")
			ss.Span().EmbeddedEnum(SingleEEnumTwo)
			ss.Span().EmbeddedEnum(SingleEEnumTwo)
			ss.Span().EmbeddedEnum(SingleEEnumThree)
			ss.Span().EmbeddedEnum(LockedEEnumTwo)
			ss.Span().EmbeddedEnum(LockedEEnumTwo)
			ss.Span().EmbeddedEnum(LockedEEnumThree)
			log.Span().EmbeddedEnum(MultipleEEnumTwo)
			log.Span().EmbeddedEnum(MultipleEEnumTwo)
			log.Span().EmbeddedEnum(MultipleEEnumThree)
			log.Span().EmbeddedEnum(DistinctEEnumTwo)
			log.Span().EmbeddedEnum(DistinctEEnumTwo)
			log.Span().EmbeddedEnum(DistinctEEnumThree)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-enum",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			ss := log.Sub().Step("stool")
			ss.Span().Enum(ExampleMetadataSingleXEnum, xopconst.SpanKindServer)
			ss.Span().Enum(ExampleMetadataSingleXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataSingleXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataLockedXEnum, xopconst.SpanKindServer)
			ss.Span().Enum(ExampleMetadataLockedXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataLockedXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataMultipleXEnum, xopconst.SpanKindServer)
			ss.Span().Enum(ExampleMetadataMultipleXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataMultipleXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataDistinctXEnum, xopconst.SpanKindServer)
			ss.Span().Enum(ExampleMetadataDistinctXEnum, xopconst.SpanKindClient)
			ss.Span().Enum(ExampleMetadataDistinctXEnum, xopconst.SpanKindClient)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-multiples",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {

			log.Span().Bool(ExampleMetadataMultipleBool, true)
			log.Span().Bool(ExampleMetadataMultipleBool, true)
			log.Span().Int(ExampleMetadataMultipleInt, 3)
			log.Span().Int(ExampleMetadataMultipleInt, 5)
			log.Span().Int(ExampleMetadataMultipleInt, 7)
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "metadata-distinct",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {

			log.Span().Bool(ExampleMetadataDistinctBool, true)
			log.Span().Bool(ExampleMetadataDistinctBool, true)
			log.Span().Bool(ExampleMetadataDistinctBool, false)
			log.Span().Int(ExampleMetadataDistinctInt, 3)
			log.Span().Int(ExampleMetadataDistinctInt, 5)
			log.Span().Int(ExampleMetadataDistinctInt, 3)
			log.Span().Int(ExampleMetadataDistinctInt, 7)
			log.Span().Int64(ExampleMetadataDistinctInt64, 73)
			log.Span().Int64(ExampleMetadataDistinctInt64, 75)
			log.Span().Int64(ExampleMetadataDistinctInt64, 73)
			log.Span().Int64(ExampleMetadataDistinctInt64, 77)
			log.Span().String(ExampleMetadataDistinctString, "abc")
			log.Span().String(ExampleMetadataDistinctString, "abc")
			log.Span().String(ExampleMetadataDistinctString, "def")
			log.Span().String(ExampleMetadataDistinctString, "abc")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "one-done",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			_ = log.Sub().Fork("a fork one done")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "prefill",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			p := log.Sub().PrefillFloat64("f", 23).PrefillText("pre!").Logger()
			p.Error().Int16("i16", int16(7)).Msg("pf")
			log.Alert().Int32("i32", int32(77)).Msgf("pf %s", "bar")
			MicroNap()
			log.Done()
		},
	},
	{
		Name:         "manipulate-seed",
		ExtraFlushes: 1,
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			l2 := log.Span().SubSeed().Request("L2")
			l2.Info().Msg("in the new log")
			MicroNap()
			l2.Done()
			log.Done()
		},
	},
	{
		Name:         "add-and-remove-loggers-with-a-seed",
		ExtraFlushes: 2,
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			tlog2 := xoptest.New(t)
			r2 := log.Span().SubSeed(xop.WithBase(tlog2)).Request("R2")
			r3 := r2.Span().SubSeed(xop.WithoutBase(tlog2)).Request("R3")
			r2.Info().Msg("log to both test loggers")
			r3.Info().Msg("log to just the original set")
			MicroNap()
			log.Done()
			r2.Done()
			r3.Done()
		},
	},
	{
		Name: "add-and-remove-loggers-with-a-span",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			tlog2 := xoptest.New(t)
			s2 := log.Sub().Step("S2", xop.WithBase(tlog2))
			s3 := s2.Sub().Detach().Fork("S3", xop.WithoutBase(tlog2))
			s2.Info().Msg("log to both test loggers")
			s3.Info().Msg("log to just the original set")
			MicroNap()
			s2.Done()
			s3.Done()
			log.Done()
		},
	},
	{
		Name:         "log-after-done",
		ExtraFlushes: 1,
		SkipOTEL:     true,
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			s2 := log.Sub().Step("S2")
			s2.Info().Int8(xop.Key("i8"), 9).Msg("a line before done")
			MicroNap()
			s2.Done()
			assert.Empty(t, tlog.Recorder().FindLines(xoprecorder.TextContains("XOP: logger was already done, but was used again")), "no err")
			s2.Info().Int16("i16", 940).Msg("a post-done line, should trigger an error log")
			assert.NotEmpty(t, tlog.Recorder().FindLines(xoprecorder.TextContains("XOP: logger was already done, but was used again")), "no err")
			assert.Empty(t, tlog.Recorder().FindLines(xoprecorder.TextContains("called on logger object when it was already Done")), "no err")
			MicroNap()
			s2.Done()
			assert.NotEmpty(t, tlog.Recorder().FindLines(xoprecorder.TextContains("called on logger object when it was already Done")), "now err")
			log.Flush()
			s2.Warn().Int32(xop.Key("i32"), 940940).Msg("another post-done line, should trigger an error log")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "lots-of-types",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			p := log.Sub().PrefillInt("pfint", 439).PrefillInt8("pfint8", 82).PrefillInt16("pfint16", 829).
				PrefillInt32("pfint32", 4328).PrefillInt64("pfint64", -2382).
				PrefillUint("pfuint", 439).PrefillUint8("pfuint8", 82).PrefillUint16("pfuint16", 829).
				PrefillUint32("pfuint32", 4328).PrefillUint64("pfuint64", 2382).
				PrefillUintptr("pfuintptr", 28).
				PrefillString("pffoo", "bar").PrefillBool("pfon/off", true).
				PrefillString("pfneedsEscaping", NeedsEscaping).
				PrefillFloat32("pff32", 92.2).
				PrefillFloat64("pff64", 292.1).
				PrefillAny("pfanyhow", map[string]interface{}{"x": "y", "z": 19}).
				PrefillEnum(ExampleMetadataMultipleXEnum, xopconst.SpanKindClient).
				PrefillEmbeddedEnum(LockedEEnumTwo).
				Logger()
			log.Warn().Int("int", 439).Int8("int8", 82).Int16("int16", 829).
				Int32("int32", 4328).Int64("int64", -2382).
				Uint("uint", 439).Uint8("uint8", 82).Uint16("uint16", 829).
				Uint32("uint32", 4328).Uint64("uint64", 2382).
				Uintptr("uintptr", 38022).
				String("foo", "bar").Bool("on/off", true).
				String("needsEscaping2", NeedsEscaping).
				Float32("f32", 92.2).
				Float64("f64", 292.1).
				Any("any", map[string]interface{}{"x": "y", "z": 19}).
				Enum(ExampleMetadataMultipleXEnum, xopconst.SpanKindClient).
				EmbeddedEnum(LockedEEnumTwo).
				Msgs("ha", true)
			p.Error().Msg("prefilled!")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "type-time",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			p := log.Sub().PrefillTime("-1m", time.Now().Add(-time.Minute).Round(time.Millisecond)).Logger()
			p.Warn().Time("now", time.Now().Round(time.Millisecond)).Msgs("time!")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "type-duration",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			p := log.Sub().PrefillDuration(xop.Key("1m"), time.Minute).Logger()
			p.Warn().Duration(xop.Key("hour"), time.Hour).Msg("duration")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "type-link",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			log.Warn().Link(log.Span().Bundle().Trace, "me, again")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "type-model",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			log.Warn().Model(map[string]interface{}{"x": "y", "z": 19}, "some stuff")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "type-error",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			p := log.Sub().PrefillError("question", fmt.Errorf("why would you pre-fill an error?")).Logger()
			p.Warn().Error("answer", fmt.Errorf("I don't know, why would you prefill an error")).Msgs(time.Now())
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "log-levels",
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			var callCount int
			sc := newStringCounter(&callCount, "foobar")
			skipper := log.Sub().MinLevel(xopnum.InfoLevel).Logger()
			skipper.Debug().
				Stringer(xop.Key("avoid"), sc).
				String(xop.Key("avoid"), "blaf").
				Any(xop.Key("null"), nil).
				Error(xop.Key("no"), fmt.Errorf("bar")).
				Msg("no foobar")
			log.Trace().Stringer("don't", sc).Msg("yes, trace")
			log.Debug().Stringer("do", sc).Msg("yes, debug")
			log.Log().Stringer("do", sc).Msg("yes, log")
			assert.Equal(t, 2, callCount, "stringer called twice")
			noSkip := log.Sub().MinLevel(xopnum.DebugLevel).Logger()
			noSkip.Debug().
				Stringer("stringer", sc).
				String("string", "blaf").
				Any("null", nil).
				Error("yes", fmt.Errorf("blaf")).
				Msg("yes foobar")
			assert.Equal(t, 3, callCount, "stringer called thrice")
			MicroNap()
			log.Done()
		},
	},
	{
		Name: "simulate-inbound-propagation",
		SeedMods: []xop.SeedModifier{
			xop.WithBundle(func() xoptrace.Bundle {
				var bundle xoptrace.Bundle
				bundle.Parent.Flags().SetString("01")
				bundle.Parent.TraceID().SetString("a60a3cc0123a043fee48839c9d52a645")
				bundle.Parent.SpanID().SetString("c63f9d81e2285f34")
				bundle.Trace = bundle.Parent
				bundle.Trace.SpanID().SetRandom()
				bundle.State.SetString("congo=t61rcWkgMzE")
				bundle.Baggage.SetString("userId=alice,serverNode=DF%2028,isProduction=false")
				return bundle
			}()),
		},
		Do: func(t *testing.T, log *xop.Logger, tlog *xoptest.Logger) {
			assert.Equal(t, "00-a60a3cc0123a043fee48839c9d52a645-c63f9d81e2285f34-01", log.Span().Bundle().Parent.String(), "trace parent")
			assert.Equal(t, "a60a3cc0123a043fee48839c9d52a645", log.Span().Bundle().Trace.GetTraceID().String(), "trace trace")
			assert.NotEqual(t, "c63f9d81e2285f34", log.Span().Bundle().Trace.GetSpanID().String(), "trace trace")
			assert.Equal(t, "congo=t61rcWkgMzE", log.Span().Bundle().State.String(), "trace state")
			assert.Equal(t, "userId=alice,serverNode=DF%2028,isProduction=false", log.Span().Bundle().Baggage.String())
			MicroNap()
			log.Done()
		},
	},
}

Functions

func MicroNap 

func MicroNap()

MicroNap makes sure that the time advances by at least a microsecond. We're guessing that lack of clock resolution is the cause of test flakiness on Windows.

func VerifyRecorderReplay added in v0.3.0 

func VerifyRecorderReplay(t *testing.T, want *xoprecorder.Logger, got *xoprecorder.Logger)

func VerifyTestReplay added in v0.3.0 

func VerifyTestReplay(t *testing.T, want *xoptest.Logger, got *xoptest.Logger)

Types

type AnyObject 

type AnyObject struct {
	I int
	S string
	A []string
	P *AnyObject
}

type TS 

type TS struct {
	time.Time
}

TS encodes time in many formats. As as number, it looks for timestamps that are in reasonable ranges.

func (*TS) UnmarshalJSON 

func (ts *TS) UnmarshalJSON(b []byte) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.