From 82f1995ea6460b292391e6cafb1cc41c139d2794 Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Fri, 24 May 2024 14:24:46 +1000 Subject: [PATCH 01/10] Consistent naming for internal event and link templates --- pkg/tracegen/templated.go | 102 +++++++++++++++++++------------------- 1 file changed, 51 insertions(+), 51 deletions(-) diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index 4e75dac..4cf5d64 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -129,18 +129,6 @@ type EventParams struct { RandomAttributes *AttributeParams `js:"randomAttributes"` } -type internalLinkParams struct { - Count int - RandomAttributes *AttributeParams -} - -type internalEventParams struct { - GenerateExceptionOnError bool - ExceptionCount int - Count int - RandomAttributes *AttributeParams -} - // NewTemplatedGenerator creates a new trace generator. func NewTemplatedGenerator(template *TraceTemplate) (*TemplatedGenerator, error) { gen := &TemplatedGenerator{} @@ -183,6 +171,18 @@ type internalResourceTemplate struct { hostPort int } +type internalLinkTemplate struct { + count int + randomAttributes *AttributeParams +} + +type internalEventTemplate struct { + count int + generateExceptionOnError bool + exceptionCount int + randomAttributes *AttributeParams +} + // Traces implements Generator for TemplatedGenerator func (g *TemplatedGenerator) Traces() ptrace.Traces { var ( @@ -525,14 +525,14 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat span.attributes = util.MergeMaps(defaults.Attributes, tmpl.Attributes) eventDefaultsRate := defaults.RandomEvents.Rate - var eventDefaults internalEventParams + var eventDefaults internalEventTemplate // if rate is more than 1, use whole integers if eventDefaultsRate > 1 { - eventDefaults = internalEventParams{ - GenerateExceptionOnError: defaults.RandomEvents.GenerateExceptionOnError, - RandomAttributes: defaults.RandomEvents.RandomAttributes, - Count: int(eventDefaultsRate), - ExceptionCount: int(defaults.RandomEvents.ExceptionRate), + eventDefaults = internalEventTemplate{ + generateExceptionOnError: defaults.RandomEvents.GenerateExceptionOnError, + randomAttributes: defaults.RandomEvents.RandomAttributes, + count: int(eventDefaultsRate), + exceptionCount: int(defaults.RandomEvents.ExceptionRate), } } else { var count, exeptionCount int @@ -545,19 +545,19 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat } // if rate is less than one - eventDefaults = internalEventParams{ - GenerateExceptionOnError: defaults.RandomEvents.GenerateExceptionOnError, - RandomAttributes: defaults.RandomEvents.RandomAttributes, - Count: count, - ExceptionCount: exeptionCount, + eventDefaults = internalEventTemplate{ + generateExceptionOnError: defaults.RandomEvents.GenerateExceptionOnError, + randomAttributes: defaults.RandomEvents.RandomAttributes, + count: count, + exceptionCount: exeptionCount, } } - randomEvents := internalEventParams{ - GenerateExceptionOnError: tmpl.RandomEvents.GenerateExceptionOnError, - RandomAttributes: tmpl.RandomEvents.RandomAttributes, - Count: int(tmpl.RandomEvents.Rate), - ExceptionCount: int(tmpl.RandomEvents.ExceptionRate), + randomEvents := internalEventTemplate{ + generateExceptionOnError: tmpl.RandomEvents.GenerateExceptionOnError, + randomAttributes: tmpl.RandomEvents.RandomAttributes, + count: int(tmpl.RandomEvents.Rate), + exceptionCount: int(tmpl.RandomEvents.ExceptionRate), } // generate all non-exception events @@ -567,22 +567,22 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat span.generateExceptionEvents = defaults.RandomEvents.GenerateExceptionOnError linkDefaultsRate := defaults.RandomLinks.Rate - var linkDefaults internalLinkParams + var linkDefaults internalLinkTemplate if linkDefaultsRate > 1 { - linkDefaults = internalLinkParams{ - RandomAttributes: defaults.RandomLinks.RandomAttributes, - Count: int(linkDefaultsRate), + linkDefaults = internalLinkTemplate{ + randomAttributes: defaults.RandomLinks.RandomAttributes, + count: int(linkDefaultsRate), } } else if rand.Float32() < linkDefaultsRate { - linkDefaults = internalLinkParams{ - RandomAttributes: defaults.RandomLinks.RandomAttributes, - Count: 1, + linkDefaults = internalLinkTemplate{ + randomAttributes: defaults.RandomLinks.RandomAttributes, + count: 1, } } - randomLinks := internalLinkParams{ - Count: int(tmpl.RandomLinks.Rate), - RandomAttributes: tmpl.RandomEvents.RandomAttributes, + randomLinks := internalLinkTemplate{ + count: int(tmpl.RandomLinks.Rate), + randomAttributes: tmpl.RandomEvents.RandomAttributes, } // initialize all links but need @@ -683,8 +683,8 @@ func initializeRandomAttributes(attributeParams *AttributeParams) map[string][]i return attributes } -func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents internalEventParams, eventDefaults internalEventParams) []Event { - count := len(tmplEvents) + randomEvents.Count + eventDefaults.Count +func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents internalEventTemplate, eventDefaults internalEventTemplate) []Event { + count := len(tmplEvents) + randomEvents.count + eventDefaults.count if count == 0 { return []Event{} @@ -697,18 +697,18 @@ func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents i events = append(events, event) } - for i := 0; i < randomEvents.ExceptionCount; i++ { + for i := 0; i < randomEvents.exceptionCount; i++ { event := generateExceptionEvent() events = append(events, event) } - for i := 0; i < randomEvents.Count; i++ { - event := generateEvent("", nil, randomEvents.RandomAttributes) + for i := 0; i < randomEvents.count; i++ { + event := generateEvent("", nil, randomEvents.randomAttributes) events = append(events, event) } - for i := 0; i < eventDefaults.Count; i++ { - event := generateEvent("", nil, eventDefaults.RandomAttributes) + for i := 0; i < eventDefaults.count; i++ { + event := generateEvent("", nil, eventDefaults.randomAttributes) events = append(events, event) } @@ -761,8 +761,8 @@ func generateRandomExceptionStackTrace() string { return "panic: " + random.SelectElement(panics) + "\n" + random.SelectElement(functions) } -func (g *TemplatedGenerator) initializeLinks(tmplLinks []Link, randomLinks internalLinkParams, linkDefaults internalLinkParams) []Link { - count := len(tmplLinks) + randomLinks.Count + linkDefaults.Count +func (g *TemplatedGenerator) initializeLinks(tmplLinks []Link, randomLinks internalLinkTemplate, linkDefaults internalLinkTemplate) []Link { + count := len(tmplLinks) + randomLinks.count + linkDefaults.count if count == 0 { return []Link{} @@ -786,17 +786,17 @@ func (g *TemplatedGenerator) initializeLinks(tmplLinks []Link, randomLinks inter links = append(links, *link) } - for i := 0; i < randomLinks.Count; i++ { + for i := 0; i < randomLinks.count; i++ { link := newLink() - for k, v := range initializeRandomAttributes(randomLinks.RandomAttributes) { + for k, v := range initializeRandomAttributes(randomLinks.randomAttributes) { link.Attributes[k] = random.SelectElement(v) } links = append(links, *link) } - for i := 0; i < linkDefaults.Count; i++ { + for i := 0; i < linkDefaults.count; i++ { link := newLink() - for k, v := range initializeRandomAttributes(linkDefaults.RandomAttributes) { + for k, v := range initializeRandomAttributes(linkDefaults.randomAttributes) { link.Attributes[k] = random.SelectElement(v) } links = append(links, *link) From a9cb542057a4dcf6ec4a25c629ebe7cca886f541 Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Fri, 24 May 2024 15:22:39 +1000 Subject: [PATCH 02/10] Initialize link attribute values during initialization Allows definition of random attributes with pre-defined cardinality --- examples/template/template.js | 11 ++- pkg/random/random.go | 4 ++ pkg/tracegen/templated.go | 118 +++++++++++++++------------------ pkg/tracegen/templated_test.go | 6 +- 4 files changed, 64 insertions(+), 75 deletions(-) diff --git a/examples/template/template.js b/examples/template/template.js index 1f6d17f..be6563f 100644 --- a/examples/template/template.js +++ b/examples/template/template.js @@ -3,7 +3,7 @@ import tracing from 'k6/x/tracing'; import { randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js'; export const options = { - vus: 1, + vus: 4, duration: "20m", }; @@ -13,7 +13,7 @@ const client = new tracing.Client({ endpoint, exporter: tracing.EXPORTER_OTLP, tls: { - insecure: true, + insecure: true, }, headers: { "X-Scope-Orgid": orgid @@ -25,7 +25,6 @@ const traceDefaults = { attributes: {"one": "three"}, randomAttributes: {count: 2, cardinality: 5}, randomEvents: {generateExceptionOnError: true, rate: 1.0, randomAttributes: {count: 2, cardinality: 3}}, - randomLinks: {rate: 1.0, randomAttributes: {count: 2, cardinality: 3}}, } const traceTemplates = [ @@ -36,7 +35,7 @@ const traceTemplates = [ {service: "shop-backend", name: "authenticate", duration: {min: 50, max: 100}}, {service: "auth-service", name: "authenticate"}, {service: "shop-backend", name: "fetch-articles", parentIdx: 0}, - {service: "article-service", name: "list-articles"}, + {service: "article-service", name: "list-articles", links: [{attributes: {"link-type": "parent-child"}, randomAttributes: {count: 2, cardinality: 5}}]}, {service: "article-service", name: "select-articles", attributeSemantics: tracing.SEMANTICS_DB}, {service: "postgres", name: "query-articles", attributeSemantics: tracing.SEMANTICS_DB, randomAttributes: {count: 5}}, ] @@ -74,7 +73,7 @@ const traceTemplates = [ {service: "shop-backend", name: "authenticate", attributes: {"http.request.header.accept": ["application/json"]}}, {service: "auth-service", name: "authenticate", attributes: {"http.status_code": 403}}, {service: "cart-service", name: "checkout", randomEvents: {exceptionRate: 1, rate: 2, randomAttributes: {count: 5, cardinality: 2}}}, - {service: "billing-service", name: "payment", randomLinks: {rate: 2, randomAttributes: {count: 3, cardinality: 2}}} + {service: "billing-service", name: "payment", randomLinks: {count: 0.5, randomAttributes: {count: 3, cardinality: 10}}} ] }, ] @@ -89,4 +88,4 @@ export default function () { export function teardown() { client.shutdown(); -} +} \ No newline at end of file diff --git a/pkg/random/random.go b/pkg/random/random.go index 8f68ea0..412a497 100644 --- a/pkg/random/random.go +++ b/pkg/random/random.go @@ -32,6 +32,10 @@ func init() { rnd = rand.New(rand.NewSource(seed.Int64())) } +func Rand() *rand.Rand { + return rnd +} + func SelectElement[T any](elements []T) T { return elements[rnd.Intn(len(elements))] } diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index 4cf5d64..306ca72 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -54,7 +54,7 @@ type SpanDefaults struct { // Random events generated for each span RandomEvents EventParams `js:"randomEvents"` // Random links generated for each span - RandomLinks LinkParams `js:"randomLinks"` + RandomLinks *LinkParams `js:"randomLinks"` } // SpanTemplate parameters that define how a span is created. @@ -84,7 +84,7 @@ type SpanTemplate struct { // Generate random events for the span RandomEvents EventParams `js:"randomEvents"` // Generate random links for the span - RandomLinks LinkParams `js:"randomLinks"` + RandomLinks *LinkParams `js:"randomLinks"` } // TraceTemplate describes how all a trace and it's spans are generated. @@ -112,8 +112,8 @@ type Event struct { } type LinkParams struct { - // Rate of random links per each span - Rate float32 `js:"rate"` + // Count of random links per each span (default: 1) + Count float32 `js:"count"` // Generate random attributes for this link RandomAttributes *AttributeParams `js:"randomAttributes"` } @@ -159,7 +159,7 @@ type internalSpanTemplate struct { attributes map[string]interface{} randomAttributes map[string][]interface{} events []Event - links []Link + links []internalLinkTemplate generateExceptionEvents bool } @@ -172,8 +172,9 @@ type internalResourceTemplate struct { } type internalLinkTemplate struct { - count int - randomAttributes *AttributeParams + rate float32 + attributes map[string]interface{} + randomAttributes map[string][]interface{} } type internalEventTemplate struct { @@ -325,12 +326,24 @@ func (g *TemplatedGenerator) generateSpan(scopeSpans ptrace.ScopeSpans, tmpl *in } } - // links + // generate links span.Links().EnsureCapacity(len(tmpl.links)) for _, l := range tmpl.links { + if l.rate > 0 && random.Rand().Float32() > l.rate { + continue + } + link := span.Links().AppendEmpty() - // default to linking to previous span if exist - // maybe we will be able support linking to specific spans in the future + link.Attributes().EnsureCapacity(len(l.attributes) + len(l.randomAttributes)) + for k, v := range l.randomAttributes { + _ = link.Attributes().PutEmpty(k).FromRaw(random.SelectElement(v)) + } + for k, v := range l.attributes { + _ = link.Attributes().PutEmpty(k).FromRaw(v) + } + + // default to linking to parent span if exist + // TODO: support linking to other existing spans if parent != nil { link.SetTraceID(traceID) link.SetSpanID(parent.SpanID()) @@ -338,9 +351,6 @@ func (g *TemplatedGenerator) generateSpan(scopeSpans ptrace.ScopeSpans, tmpl *in link.SetTraceID(random.TraceID()) link.SetSpanID(random.SpanID()) } - for k, v := range l.Attributes { - _ = link.Attributes().PutEmpty(k).FromRaw(v) - } } return span @@ -566,28 +576,6 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat // need span status to determine if an exception event should occur span.generateExceptionEvents = defaults.RandomEvents.GenerateExceptionOnError - linkDefaultsRate := defaults.RandomLinks.Rate - var linkDefaults internalLinkTemplate - if linkDefaultsRate > 1 { - linkDefaults = internalLinkTemplate{ - randomAttributes: defaults.RandomLinks.RandomAttributes, - count: int(linkDefaultsRate), - } - } else if rand.Float32() < linkDefaultsRate { - linkDefaults = internalLinkTemplate{ - randomAttributes: defaults.RandomLinks.RandomAttributes, - count: 1, - } - } - - randomLinks := internalLinkTemplate{ - count: int(tmpl.RandomLinks.Rate), - randomAttributes: tmpl.RandomEvents.RandomAttributes, - } - - // initialize all links but need - span.links = g.initializeLinks(tmpl.Links, randomLinks, linkDefaults) - // set span name if tmpl.Name != nil { span.name = *tmpl.Name @@ -603,6 +591,9 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat span.randomAttributes = initializeRandomAttributes(tmpl.RandomAttributes) + // initialize links for span + span.links = g.initializeLinks(tmpl.Links, tmpl.RandomLinks, defaults.RandomLinks) + return &span, nil } @@ -761,46 +752,41 @@ func generateRandomExceptionStackTrace() string { return "panic: " + random.SelectElement(panics) + "\n" + random.SelectElement(functions) } -func (g *TemplatedGenerator) initializeLinks(tmplLinks []Link, randomLinks internalLinkTemplate, linkDefaults internalLinkTemplate) []Link { - count := len(tmplLinks) + randomLinks.count + linkDefaults.count - - if count == 0 { - return []Link{} - } +func (g *TemplatedGenerator) initializeLinks(linkTemplates []Link, randomLinks, defaultRandomLinks *LinkParams) []internalLinkTemplate { + internalLinks := make([]internalLinkTemplate, 0, len(linkTemplates)) - links := make([]Link, 0, count) - newLink := func() *Link { - return &Link{ - Attributes: make(map[string]interface{}), + for _, lt := range linkTemplates { + link := internalLinkTemplate{ + attributes: lt.Attributes, + randomAttributes: initializeRandomAttributes(lt.RandomAttributes), } + internalLinks = append(internalLinks, link) } - for _, l := range tmplLinks { - link := newLink() - for k, v := range l.Attributes { - link.Attributes[k] = v + if randomLinks == nil { + if defaultRandomLinks == nil { + return internalLinks } - for k, v := range initializeRandomAttributes(l.RandomAttributes) { - link.Attributes[k] = random.SelectElement(v) - } - links = append(links, *link) + randomLinks = defaultRandomLinks } - - for i := 0; i < randomLinks.count; i++ { - link := newLink() - for k, v := range initializeRandomAttributes(randomLinks.randomAttributes) { - link.Attributes[k] = random.SelectElement(v) - } - links = append(links, *link) + if randomLinks.Count == 0 { // default count is 1 + randomLinks.Count = 1 } - for i := 0; i < linkDefaults.count; i++ { - link := newLink() - for k, v := range initializeRandomAttributes(linkDefaults.randomAttributes) { - link.Attributes[k] = random.SelectElement(v) + if randomLinks.Count < 1 { + link := internalLinkTemplate{ + rate: randomLinks.Count, + randomAttributes: initializeRandomAttributes(randomLinks.RandomAttributes), + } + internalLinks = append(internalLinks, link) + } else { + for i := 0; i < int(randomLinks.Count); i++ { + link := internalLinkTemplate{ + randomAttributes: initializeRandomAttributes(randomLinks.RandomAttributes), + } + internalLinks = append(internalLinks, link) } - links = append(links, *link) } - return links + return internalLinks } diff --git a/pkg/tracegen/templated_test.go b/pkg/tracegen/templated_test.go index a4c0033..21f73b8 100644 --- a/pkg/tracegen/templated_test.go +++ b/pkg/tracegen/templated_test.go @@ -58,15 +58,15 @@ func TestTemplatedGenerator_EventsLinks(t *testing.T) { Defaults: SpanDefaults{ Attributes: map[string]interface{}{"fixed.attr": "some-value"}, RandomAttributes: &AttributeParams{Count: 3}, - RandomLinks: LinkParams{Rate: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, + RandomLinks: &LinkParams{Count: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, RandomEvents: EventParams{GenerateExceptionOnError: true, Rate: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, }, Spans: []SpanTemplate{ // do not change order of the first one {Service: "test-service", Name: ptr("only_default")}, {Service: "test-service", Name: ptr("default_and_template"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}}, - {Service: "test-service", Name: ptr("default_and_random"), RandomEvents: EventParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: LinkParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}}, - {Service: "test-service", Name: ptr("default_template_random"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}, RandomEvents: EventParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: LinkParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}}, + {Service: "test-service", Name: ptr("default_and_random"), RandomEvents: EventParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, + {Service: "test-service", Name: ptr("default_template_random"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}, RandomEvents: EventParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, {Service: "test-service", Name: ptr("default_generate_on_error"), Attributes: map[string]interface{}{"http.status_code": 400}}, }, } From 67a3a9229ac9e3a5f1a3ad14fc1176f37a82295d Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Mon, 27 May 2024 15:18:28 +1000 Subject: [PATCH 03/10] Rename EventParam.Rate and remove unused generateExceptionOnError: --- pkg/tracegen/templated.go | 36 +++++++++++++++------------------- pkg/tracegen/templated_test.go | 6 +++--- 2 files changed, 19 insertions(+), 23 deletions(-) diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index 306ca72..be3d148 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -121,10 +121,10 @@ type LinkParams struct { type EventParams struct { // Generate exception event if status code of the span is >= 400 GenerateExceptionOnError bool `js:"generateExceptionOnError"` - // Rate of exception events per each span + // Count of exception events per each span ExceptionRate float32 `js:"exceptionRate"` - // Rate of random events per each span - Rate float32 `js:"rate"` + // Count of random events per each span + Count float32 `js:"count"` // Generate random attributes for this event RandomAttributes *AttributeParams `js:"randomAttributes"` } @@ -178,10 +178,9 @@ type internalLinkTemplate struct { } type internalEventTemplate struct { - count int - generateExceptionOnError bool - exceptionCount int - randomAttributes *AttributeParams + count int + exceptionCount int + randomAttributes *AttributeParams } // Traces implements Generator for TemplatedGenerator @@ -534,15 +533,14 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat } span.attributes = util.MergeMaps(defaults.Attributes, tmpl.Attributes) - eventDefaultsRate := defaults.RandomEvents.Rate + eventDefaultsRate := defaults.RandomEvents.Count var eventDefaults internalEventTemplate // if rate is more than 1, use whole integers if eventDefaultsRate > 1 { eventDefaults = internalEventTemplate{ - generateExceptionOnError: defaults.RandomEvents.GenerateExceptionOnError, - randomAttributes: defaults.RandomEvents.RandomAttributes, - count: int(eventDefaultsRate), - exceptionCount: int(defaults.RandomEvents.ExceptionRate), + randomAttributes: defaults.RandomEvents.RandomAttributes, + count: int(eventDefaultsRate), + exceptionCount: int(defaults.RandomEvents.ExceptionRate), } } else { var count, exeptionCount int @@ -556,18 +554,16 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat // if rate is less than one eventDefaults = internalEventTemplate{ - generateExceptionOnError: defaults.RandomEvents.GenerateExceptionOnError, - randomAttributes: defaults.RandomEvents.RandomAttributes, - count: count, - exceptionCount: exeptionCount, + randomAttributes: defaults.RandomEvents.RandomAttributes, + count: count, + exceptionCount: exeptionCount, } } randomEvents := internalEventTemplate{ - generateExceptionOnError: tmpl.RandomEvents.GenerateExceptionOnError, - randomAttributes: tmpl.RandomEvents.RandomAttributes, - count: int(tmpl.RandomEvents.Rate), - exceptionCount: int(tmpl.RandomEvents.ExceptionRate), + randomAttributes: tmpl.RandomEvents.RandomAttributes, + count: int(tmpl.RandomEvents.Count), + exceptionCount: int(tmpl.RandomEvents.ExceptionRate), } // generate all non-exception events diff --git a/pkg/tracegen/templated_test.go b/pkg/tracegen/templated_test.go index 21f73b8..97e4e20 100644 --- a/pkg/tracegen/templated_test.go +++ b/pkg/tracegen/templated_test.go @@ -59,14 +59,14 @@ func TestTemplatedGenerator_EventsLinks(t *testing.T) { Attributes: map[string]interface{}{"fixed.attr": "some-value"}, RandomAttributes: &AttributeParams{Count: 3}, RandomLinks: &LinkParams{Count: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, - RandomEvents: EventParams{GenerateExceptionOnError: true, Rate: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, + RandomEvents: EventParams{GenerateExceptionOnError: true, Count: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, }, Spans: []SpanTemplate{ // do not change order of the first one {Service: "test-service", Name: ptr("only_default")}, {Service: "test-service", Name: ptr("default_and_template"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}}, - {Service: "test-service", Name: ptr("default_and_random"), RandomEvents: EventParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, - {Service: "test-service", Name: ptr("default_template_random"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}, RandomEvents: EventParams{Rate: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, + {Service: "test-service", Name: ptr("default_and_random"), RandomEvents: EventParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, + {Service: "test-service", Name: ptr("default_template_random"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}, RandomEvents: EventParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, {Service: "test-service", Name: ptr("default_generate_on_error"), Attributes: map[string]interface{}{"http.status_code": 400}}, }, } From 2828cecd771d000991dfb76c6807053bf22355cf Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Mon, 27 May 2024 17:01:48 +1000 Subject: [PATCH 04/10] Initialize event attribute values during initialization Allows definition of random attributes with pre-defined cardinality --- examples/template/template.js | 11 +- pkg/tracegen/templated.go | 218 ++++++++++++++++----------------- pkg/tracegen/templated_test.go | 6 +- 3 files changed, 117 insertions(+), 118 deletions(-) diff --git a/examples/template/template.js b/examples/template/template.js index be6563f..d846c20 100644 --- a/examples/template/template.js +++ b/examples/template/template.js @@ -44,6 +44,7 @@ const traceTemplates = [ defaults: { attributes: {"numbers": ["one", "two", "three"]}, attributeSemantics: tracing.SEMANTICS_HTTP, + randomEvents: {count: 2, randomAttributes: {count: 3, cardinality: 10}}, }, spans: [ {service: "shop-backend", name: "article-to-cart", duration: {min: 400, max: 1200}}, @@ -63,17 +64,17 @@ const traceTemplates = [ spans: [ {service: "shop-backend", attributes: {"http.status_code": 403}}, {service: "shop-backend", name: "authenticate", attributes: {"http.request.header.accept": ["application/json"]}}, - {service: "auth-service", name: "authenticate", attributes: {"http.status_code": 403}}, + {service: "auth-service", name: "authenticate", attributes: {"http.status_code": 403}, randomEvents: {count: 0.5, exceptionCount: 2, randomAttributes: {count: 5, cardinality: 5}}}, ] }, { defaults: traceDefaults, spans: [ - {service: "shop-backend", attributes: {"http.status_code": 403}}, + {service: "shop-backend"}, {service: "shop-backend", name: "authenticate", attributes: {"http.request.header.accept": ["application/json"]}}, - {service: "auth-service", name: "authenticate", attributes: {"http.status_code": 403}}, - {service: "cart-service", name: "checkout", randomEvents: {exceptionRate: 1, rate: 2, randomAttributes: {count: 5, cardinality: 2}}}, - {service: "billing-service", name: "payment", randomLinks: {count: 0.5, randomAttributes: {count: 3, cardinality: 10}}} + {service: "auth-service", name: "authenticate"}, + {service: "cart-service", name: "checkout", randomEvents: {count: 0.5, exceptionCount: 2, exceptionOnError: true, randomAttributes: {count: 5, cardinality: 5}}}, + {service: "billing-service", name: "payment", randomLinks: {count: 0.5, randomAttributes: {count: 3, cardinality: 10}}, randomEvents: {exceptionOnError: true, randomAttributes: {count: 4}}} ] }, ] diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index be3d148..134d793 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -2,7 +2,6 @@ package tracegen import ( "fmt" - "math/rand" "net/http" "net/url" "strings" @@ -52,7 +51,7 @@ type SpanDefaults struct { // RandomAttributes random attributes generated for each span. RandomAttributes *AttributeParams `js:"randomAttributes"` // Random events generated for each span - RandomEvents EventParams `js:"randomEvents"` + RandomEvents *EventParams `js:"randomEvents"` // Random links generated for each span RandomLinks *LinkParams `js:"randomLinks"` } @@ -82,7 +81,7 @@ type SpanTemplate struct { // List of links for the span with specific parameters Links []Link `js:"links"` // Generate random events for the span - RandomEvents EventParams `js:"randomEvents"` + RandomEvents *EventParams `js:"randomEvents"` // Generate random links for the span RandomLinks *LinkParams `js:"randomLinks"` } @@ -119,12 +118,12 @@ type LinkParams struct { } type EventParams struct { - // Generate exception event if status code of the span is >= 400 - GenerateExceptionOnError bool `js:"generateExceptionOnError"` - // Count of exception events per each span - ExceptionRate float32 `js:"exceptionRate"` // Count of random events per each span Count float32 `js:"count"` + // ExceptionCount indicates how many exception events to add to the span + ExceptionCount float32 `js:"exceptionCount"` + // ExceptionOnError generates exceptions if status code of the span is >= 400 + ExceptionOnError bool `js:"exceptionOnError"` // Generate random attributes for this event RandomAttributes *AttributeParams `js:"randomAttributes"` } @@ -149,18 +148,17 @@ type TemplatedGenerator struct { } type internalSpanTemplate struct { - idx int - resource *internalResourceTemplate - parent *internalSpanTemplate - name string - kind ptrace.SpanKind - duration *Range - attributeSemantics *OTelSemantics - attributes map[string]interface{} - randomAttributes map[string][]interface{} - events []Event - links []internalLinkTemplate - generateExceptionEvents bool + idx int + resource *internalResourceTemplate + parent *internalSpanTemplate + name string + kind ptrace.SpanKind + duration *Range + attributeSemantics *OTelSemantics + attributes map[string]interface{} + randomAttributes map[string][]interface{} + events []internalEventTemplate + links []internalLinkTemplate } type internalResourceTemplate struct { @@ -178,9 +176,11 @@ type internalLinkTemplate struct { } type internalEventTemplate struct { - count int - exceptionCount int - randomAttributes *AttributeParams + rate float32 + exceptionOnError bool + name string + attributes map[string]interface{} + randomAttributes map[string][]interface{} } // Traces implements Generator for TemplatedGenerator @@ -288,40 +288,35 @@ func (g *TemplatedGenerator) generateSpan(scopeSpans ptrace.ScopeSpans, tmpl *in } } - // events + // generate events + var hasError bool + if st, found := span.Attributes().Get("http.status_code"); found { + hasError = st.Int() >= 400 + } else if st, found = span.Attributes().Get("http.response.status_code"); found { + hasError = st.Int() >= 400 + } span.Events().EnsureCapacity(len(tmpl.events)) for _, e := range tmpl.events { - event := span.Events().AppendEmpty() - event.SetName(e.Name) - event.SetTimestamp(pcommon.NewTimestampFromTime(end)) - for k, v := range e.Attributes { - _ = event.Attributes().PutEmpty(k).FromRaw(v) + if e.rate > 0 && random.Rand().Float32() > e.rate { + continue } - } - - if tmpl.generateExceptionEvents { - var status int64 - parentAttr := pcommon.NewMap() - if parent != nil { - parentAttr = parent.Attributes() + if e.exceptionOnError && !hasError { + continue } - if st, found := span.Attributes().Get("http.status_code"); found { - status = st.Int() - } else if st, found = parentAttr.Get("http.status_code"); found { - status = st.Int() - } else { - status = random.HTTPStatusSuccess() - span.Attributes().PutInt("http.status_code", status) + + event := span.Events().AppendEmpty() + event.Attributes().EnsureCapacity(len(e.attributes) + len(e.randomAttributes)) + + event.SetName(e.name) + eventTime := start.Add(random.Duration(0, duration)) + event.SetTimestamp(pcommon.NewTimestampFromTime(eventTime)) + + for k, v := range e.attributes { + _ = event.Attributes().PutEmpty(k).FromRaw(v) } - if status >= 400 { - exceptionEvent := generateExceptionEvent() - event := span.Events().AppendEmpty() - event.SetName(exceptionEvent.Name) - event.SetTimestamp(pcommon.NewTimestampFromTime(end)) - for k, v := range exceptionEvent.Attributes { - _ = event.Attributes().PutEmpty(k).FromRaw(v) - } + for k, v := range e.randomAttributes { + _ = event.Attributes().PutEmpty(k).FromRaw(random.SelectElement(v)) } } @@ -533,45 +528,6 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat } span.attributes = util.MergeMaps(defaults.Attributes, tmpl.Attributes) - eventDefaultsRate := defaults.RandomEvents.Count - var eventDefaults internalEventTemplate - // if rate is more than 1, use whole integers - if eventDefaultsRate > 1 { - eventDefaults = internalEventTemplate{ - randomAttributes: defaults.RandomEvents.RandomAttributes, - count: int(eventDefaultsRate), - exceptionCount: int(defaults.RandomEvents.ExceptionRate), - } - } else { - var count, exeptionCount int - if rand.Float32() < eventDefaultsRate { - count = 1 - } - - if rand.Float32() < eventDefaultsRate { - exeptionCount = 1 - } - - // if rate is less than one - eventDefaults = internalEventTemplate{ - randomAttributes: defaults.RandomEvents.RandomAttributes, - count: count, - exceptionCount: exeptionCount, - } - } - - randomEvents := internalEventTemplate{ - randomAttributes: tmpl.RandomEvents.RandomAttributes, - count: int(tmpl.RandomEvents.Count), - exceptionCount: int(tmpl.RandomEvents.ExceptionRate), - } - - // generate all non-exception events - span.events = g.initializeEvents(tmpl.Events, randomEvents, eventDefaults) - - // need span status to determine if an exception event should occur - span.generateExceptionEvents = defaults.RandomEvents.GenerateExceptionOnError - // set span name if tmpl.Name != nil { span.name = *tmpl.Name @@ -590,6 +546,9 @@ func (g *TemplatedGenerator) initializeSpan(idx int, parent *internalSpanTemplat // initialize links for span span.links = g.initializeLinks(tmpl.Links, tmpl.RandomLinks, defaults.RandomLinks) + // initialize events for the span + span.events = g.initializeEvents(tmpl.Events, tmpl.RandomEvents, defaults.RandomEvents) + return &span, nil } @@ -670,36 +629,75 @@ func initializeRandomAttributes(attributeParams *AttributeParams) map[string][]i return attributes } -func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents internalEventTemplate, eventDefaults internalEventTemplate) []Event { - count := len(tmplEvents) + randomEvents.count + eventDefaults.count - - if count == 0 { - return []Event{} - } - - events := make([]Event, 0, count) - +func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents, defaultRandomEvents *EventParams) []internalEventTemplate { + internalEvents := make([]internalEventTemplate, 0, len(tmplEvents)) for _, e := range tmplEvents { - event := generateEvent(e.Name, e.Attributes, e.RandomAttributes) - events = append(events, event) + event := internalEventTemplate{ + name: e.Name, + attributes: e.Attributes, + randomAttributes: initializeRandomAttributes(e.RandomAttributes), + } + internalEvents = append(internalEvents, event) } - for i := 0; i < randomEvents.exceptionCount; i++ { - event := generateExceptionEvent() - events = append(events, event) + if randomEvents == nil { + if defaultRandomEvents == nil { + return internalEvents + } + randomEvents = defaultRandomEvents } - for i := 0; i < randomEvents.count; i++ { - event := generateEvent("", nil, randomEvents.randomAttributes) - events = append(events, event) + // normal random events + if randomEvents.Count == 0 { // default count is 1 + randomEvents.Count = 1 + } + if randomEvents.Count < 1 { + event := internalEventTemplate{ + rate: randomEvents.Count, + name: "event_" + random.K6String(10), + randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), + } + internalEvents = append(internalEvents, event) + } else { + for i := 0; i < int(randomEvents.Count); i++ { + event := internalEventTemplate{ + name: "event_" + random.K6String(10), + randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), + } + internalEvents = append(internalEvents, event) + } } - for i := 0; i < eventDefaults.count; i++ { - event := generateEvent("", nil, eventDefaults.randomAttributes) - events = append(events, event) + // random exception events + if randomEvents.ExceptionCount == 0 && randomEvents.ExceptionOnError { + randomEvents.ExceptionCount = 1 // default exception count is 1, if ExceptionOnError is true + } + if randomEvents.ExceptionCount < 1 { + event := internalEventTemplate{ + rate: randomEvents.Count, + name: "event_" + random.K6String(10), + randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), + exceptionOnError: randomEvents.ExceptionOnError, + } + internalEvents = append(internalEvents, event) + } else { + for i := 0; i < int(randomEvents.ExceptionCount); i++ { + event := internalEventTemplate{ + name: "exception", + attributes: map[string]interface{}{ + "exception.escape": false, + "exception.message": generateRandomExceptionMsg(), + "exception.stacktrace": generateRandomExceptionStackTrace(), + "exception.type": random.K6String(10) + ".error", + }, + randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), + exceptionOnError: randomEvents.ExceptionOnError, + } + internalEvents = append(internalEvents, event) + } } - return events + return internalEvents } func generateExceptionEvent() Event { diff --git a/pkg/tracegen/templated_test.go b/pkg/tracegen/templated_test.go index 97e4e20..23608bf 100644 --- a/pkg/tracegen/templated_test.go +++ b/pkg/tracegen/templated_test.go @@ -59,14 +59,14 @@ func TestTemplatedGenerator_EventsLinks(t *testing.T) { Attributes: map[string]interface{}{"fixed.attr": "some-value"}, RandomAttributes: &AttributeParams{Count: 3}, RandomLinks: &LinkParams{Count: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, - RandomEvents: EventParams{GenerateExceptionOnError: true, Count: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, + RandomEvents: &EventParams{ExceptionOnError: true, Count: 0.5, RandomAttributes: &AttributeParams{Count: 3}}, }, Spans: []SpanTemplate{ // do not change order of the first one {Service: "test-service", Name: ptr("only_default")}, {Service: "test-service", Name: ptr("default_and_template"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}}, - {Service: "test-service", Name: ptr("default_and_random"), RandomEvents: EventParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, - {Service: "test-service", Name: ptr("default_template_random"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}, RandomEvents: EventParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, + {Service: "test-service", Name: ptr("default_and_random"), RandomEvents: &EventParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, + {Service: "test-service", Name: ptr("default_template_random"), Events: []Event{{Name: "event-name", RandomAttributes: &AttributeParams{Count: 2}}}, Links: []Link{{Attributes: map[string]interface{}{"link-attr-key": "link-attr-value"}}}, RandomEvents: &EventParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}, RandomLinks: &LinkParams{Count: 2, RandomAttributes: &AttributeParams{Count: 1}}}, {Service: "test-service", Name: ptr("default_generate_on_error"), Attributes: map[string]interface{}{"http.status_code": 400}}, }, } From addea40a2f955342602968e6bbbfe109eff46b51 Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Tue, 28 May 2024 10:01:46 +1000 Subject: [PATCH 05/10] Remove unused functions --- pkg/tracegen/templated.go | 33 --------------------------------- 1 file changed, 33 deletions(-) diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index 134d793..225bc2a 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -700,39 +700,6 @@ func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents, return internalEvents } -func generateExceptionEvent() Event { - return Event{ - Name: "exception", - Attributes: map[string]interface{}{ - "exception.escape": false, - "exception.message": generateRandomExceptionMsg(), - "exception.stacktrace": generateRandomExceptionStackTrace(), - "exception.type": random.K6String(10) + ".error", - }, - } -} - -func generateEvent(name string, attributes map[string]interface{}, randomAttr *AttributeParams) Event { - event := Event{ - Attributes: make(map[string]interface{}), - } - - if name != "" { - event.Name = name - } else { - event.Name = "event " + random.K6String(10) - } - - for k, v := range attributes { - event.Attributes[k] = v - } - - for k, v := range initializeRandomAttributes(randomAttr) { - event.Attributes[k] = random.SelectElement(v) - } - return event -} - func generateRandomExceptionMsg() string { return "error: " + random.K6String(20) } From 1c6da5a84b6c7f0669e3651fd6ce918198d27611 Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Tue, 28 May 2024 10:06:04 +1000 Subject: [PATCH 06/10] Common function random.EventName() --- pkg/random/random.go | 4 ++++ pkg/tracegen/templated.go | 8 ++++---- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/pkg/random/random.go b/pkg/random/random.go index 412a497..ff3dc6d 100644 --- a/pkg/random/random.go +++ b/pkg/random/random.go @@ -125,3 +125,7 @@ func SpanID() pcommon.SpanID { _, _ = rnd.Read(b[:]) // always returns nil error return b } + +func EventName() string { + return "event_k6." + String(10) +} diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index 225bc2a..d11892b 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -654,14 +654,14 @@ func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents, if randomEvents.Count < 1 { event := internalEventTemplate{ rate: randomEvents.Count, - name: "event_" + random.K6String(10), + name: random.EventName(), randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), } internalEvents = append(internalEvents, event) } else { for i := 0; i < int(randomEvents.Count); i++ { event := internalEventTemplate{ - name: "event_" + random.K6String(10), + name: random.EventName(), randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), } internalEvents = append(internalEvents, event) @@ -675,7 +675,7 @@ func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents, if randomEvents.ExceptionCount < 1 { event := internalEventTemplate{ rate: randomEvents.Count, - name: "event_" + random.K6String(10), + name: random.EventName(), randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), exceptionOnError: randomEvents.ExceptionOnError, } @@ -688,7 +688,7 @@ func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents, "exception.escape": false, "exception.message": generateRandomExceptionMsg(), "exception.stacktrace": generateRandomExceptionStackTrace(), - "exception.type": random.K6String(10) + ".error", + "exception.type": "error.type_" + random.K6String(10), }, randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), exceptionOnError: randomEvents.ExceptionOnError, From 81bff44651c2c856683c9d0bd75ad11eff7be42a Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Tue, 28 May 2024 10:29:16 +1000 Subject: [PATCH 07/10] Fix random exception generation based on exceptionCount --- pkg/tracegen/templated.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/pkg/tracegen/templated.go b/pkg/tracegen/templated.go index d11892b..4dc03dd 100644 --- a/pkg/tracegen/templated.go +++ b/pkg/tracegen/templated.go @@ -674,8 +674,14 @@ func (g *TemplatedGenerator) initializeEvents(tmplEvents []Event, randomEvents, } if randomEvents.ExceptionCount < 1 { event := internalEventTemplate{ - rate: randomEvents.Count, - name: random.EventName(), + rate: randomEvents.ExceptionCount, + name: "exception", + attributes: map[string]interface{}{ + "exception.escape": false, + "exception.message": generateRandomExceptionMsg(), + "exception.stacktrace": generateRandomExceptionStackTrace(), + "exception.type": "error.type_" + random.K6String(10), + }, randomAttributes: initializeRandomAttributes(randomEvents.RandomAttributes), exceptionOnError: randomEvents.ExceptionOnError, } From ad213b5c120d2040b24edbecfc31bd79e3a9e1ba Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Tue, 28 May 2024 09:44:11 +1000 Subject: [PATCH 08/10] Update example template.js --- examples/template/template.js | 29 +++++++++++++++++++++++------ 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/examples/template/template.js b/examples/template/template.js index d846c20..452387f 100644 --- a/examples/template/template.js +++ b/examples/template/template.js @@ -3,7 +3,7 @@ import tracing from 'k6/x/tracing'; import { randomIntBetween } from 'https://jslib.k6.io/k6-utils/1.2.0/index.js'; export const options = { - vus: 4, + vus: 1, duration: "20m", }; @@ -24,7 +24,7 @@ const traceDefaults = { attributeSemantics: tracing.SEMANTICS_HTTP, attributes: {"one": "three"}, randomAttributes: {count: 2, cardinality: 5}, - randomEvents: {generateExceptionOnError: true, rate: 1.0, randomAttributes: {count: 2, cardinality: 3}}, + randomEvents: {count: 0.1, exceptionCount: 0.2, randomAttributes: {count: 6, cardinality: 20}}, } const traceTemplates = [ @@ -35,7 +35,11 @@ const traceTemplates = [ {service: "shop-backend", name: "authenticate", duration: {min: 50, max: 100}}, {service: "auth-service", name: "authenticate"}, {service: "shop-backend", name: "fetch-articles", parentIdx: 0}, - {service: "article-service", name: "list-articles", links: [{attributes: {"link-type": "parent-child"}, randomAttributes: {count: 2, cardinality: 5}}]}, + { + service: "article-service", + name: "list-articles", + links: [{attributes: {"link-type": "parent-child"}, randomAttributes: {count: 2, cardinality: 5}}] + }, {service: "article-service", name: "select-articles", attributeSemantics: tracing.SEMANTICS_DB}, {service: "postgres", name: "query-articles", attributeSemantics: tracing.SEMANTICS_DB, randomAttributes: {count: 5}}, ] @@ -64,7 +68,12 @@ const traceTemplates = [ spans: [ {service: "shop-backend", attributes: {"http.status_code": 403}}, {service: "shop-backend", name: "authenticate", attributes: {"http.request.header.accept": ["application/json"]}}, - {service: "auth-service", name: "authenticate", attributes: {"http.status_code": 403}, randomEvents: {count: 0.5, exceptionCount: 2, randomAttributes: {count: 5, cardinality: 5}}}, + { + service: "auth-service", + name: "authenticate", + attributes: {"http.status_code": 403}, + randomEvents: {count: 0.5, exceptionCount: 2, randomAttributes: {count: 5, cardinality: 5}} + }, ] }, { @@ -73,8 +82,16 @@ const traceTemplates = [ {service: "shop-backend"}, {service: "shop-backend", name: "authenticate", attributes: {"http.request.header.accept": ["application/json"]}}, {service: "auth-service", name: "authenticate"}, - {service: "cart-service", name: "checkout", randomEvents: {count: 0.5, exceptionCount: 2, exceptionOnError: true, randomAttributes: {count: 5, cardinality: 5}}}, - {service: "billing-service", name: "payment", randomLinks: {count: 0.5, randomAttributes: {count: 3, cardinality: 10}}, randomEvents: {exceptionOnError: true, randomAttributes: {count: 4}}} + { + service: "cart-service", + name: "checkout", + randomEvents: {count: 0.5, exceptionCount: 2, exceptionOnError: true, randomAttributes: {count: 5, cardinality: 5}} + }, + { + service: "billing-service", + name: "payment", + randomLinks: {count: 0.5, randomAttributes: {count: 3, cardinality: 10}}, + randomEvents: {exceptionOnError: true, randomAttributes: {count: 4}}} ] }, ] From 8fb3ca5d5a986dac457e11938722f43f9670c613 Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Tue, 28 May 2024 11:02:17 +1000 Subject: [PATCH 09/10] Upgrade Go and golangci-lint versions --- .github/workflows/lint-test.yml | 4 ++-- .github/workflows/release.yml | 2 +- Dockerfile | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/lint-test.yml b/.github/workflows/lint-test.yml index 8d152fb..46d301f 100644 --- a/.github/workflows/lint-test.yml +++ b/.github/workflows/lint-test.yml @@ -12,13 +12,13 @@ jobs: - name: Set-up Go uses: actions/setup-go@v3 with: - go-version: ^1.21 + go-version: ^1.22 cache: true - name: Lint uses: golangci/golangci-lint-action@v3 with: - version: v1.55.2 + version: v1.59.0 args: --config ./golangci.yml - name: Test diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index afa2745..146024b 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -14,7 +14,7 @@ jobs: - name: Set-up Go uses: actions/setup-go@v3 with: - go-version: ^1.19 + go-version: ^1.22 cache: true - name: Test diff --git a/Dockerfile b/Dockerfile index d976ded..a16159a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.21-alpine AS xk6-client-tracing-build +FROM golang:1.22-alpine AS xk6-client-tracing-build RUN apk add --no-cache \ build-base \ @@ -7,7 +7,7 @@ RUN apk add --no-cache \ make RUN go install go.k6.io/xk6/cmd/xk6@latest \ - && wget -O- -nv https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.50.0 \ + && wget -O- -nv https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.59.0 \ && golangci-lint --version WORKDIR /opt/xk6-client-tracing From 14f3de6541cb1a9cf99c746e9d0fcbbb88a483c5 Mon Sep 17 00:00:00 2001 From: "A. Stoewer" Date: Thu, 30 May 2024 07:18:11 +1000 Subject: [PATCH 10/10] Change package name to clienttracing --- tracing.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tracing.go b/tracing.go index 8092b7e..355142e 100644 --- a/tracing.go +++ b/tracing.go @@ -1,4 +1,4 @@ -package xk6_client_tracing +package clienttracing import ( "context"