mirrors/woodpecker
1
0
Fork 0
mirror of https://github.com/woodpecker-ci/woodpecker.git synced 2024-06-02 21:49:25 +00:00
Code Issues Projects Releases Wiki Activity

chore: generate traced wrappers

Browse source 
Signed-off-by: Mateusz Urbanek <mateusz.urbanek.98@gmail.com>
This commit is contained in:
Mateusz Urbanek 2024-05-19 10:43:49 +02:00
parent 8a41456233
commit 111c5dfaed
No known key found for this signature in database
GPG key ID: 965531459857EDA0
9 changed files with 2103 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

214
pipeline/backend/types/traced/tracedbackend.gen.go Normal file
View file

@ -0,0 +1,214 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/pipeline/backend/types -i Backend -t ../../../../templates/opentelemetry.go.tpl -o tracedbackend.gen.go -l ""
import (
"context"
"io"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/pipeline/backend/types"
)
// BackendWithTracing implements types.Backend interface instrumented with opentracing spans
type BackendWithTracing struct {
types.Backend
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewBackendWithTracing returns BackendWithTracing
func NewBackendWithTracing(base types.Backend, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) BackendWithTracing {
d := BackendWithTracing{
Backend: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// DestroyStep implements types.Backend
func (_d BackendWithTracing) DestroyStep(ctx context.Context, step *types.Step, taskUUID string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.DestroyStep")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"step": step,
"taskUUID": taskUUID}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.DestroyStep(ctx, step, taskUUID)
}
// DestroyWorkflow implements types.Backend
func (_d BackendWithTracing) DestroyWorkflow(ctx context.Context, conf *types.Config, taskUUID string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.DestroyWorkflow")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"conf": conf,
"taskUUID": taskUUID}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.DestroyWorkflow(ctx, conf, taskUUID)
}
// IsAvailable implements types.Backend
func (_d BackendWithTracing) IsAvailable(ctx context.Context) (b1 bool) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.IsAvailable")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx}, map[string]interface{}{
"b1": b1})
}
_span.End()
}()
return _d.Backend.IsAvailable(ctx)
}
// Load implements types.Backend
func (_d BackendWithTracing) Load(ctx context.Context) (bp1 *types.BackendInfo, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.Load")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx}, map[string]interface{}{
"bp1": bp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.Load(ctx)
}
// SetupWorkflow implements types.Backend
func (_d BackendWithTracing) SetupWorkflow(ctx context.Context, conf *types.Config, taskUUID string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.SetupWorkflow")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"conf": conf,
"taskUUID": taskUUID}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.SetupWorkflow(ctx, conf, taskUUID)
}
// StartStep implements types.Backend
func (_d BackendWithTracing) StartStep(ctx context.Context, step *types.Step, taskUUID string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.StartStep")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"step": step,
"taskUUID": taskUUID}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.StartStep(ctx, step, taskUUID)
}
// TailStep implements types.Backend
func (_d BackendWithTracing) TailStep(ctx context.Context, step *types.Step, taskUUID string) (r1 io.ReadCloser, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.TailStep")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"step": step,
"taskUUID": taskUUID}, map[string]interface{}{
"r1": r1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.TailStep(ctx, step, taskUUID)
}
// WaitStep implements types.Backend
func (_d BackendWithTracing) WaitStep(ctx context.Context, step *types.Step, taskUUID string) (sp1 *types.State, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "types.Backend.WaitStep")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"step": step,
"taskUUID": taskUUID}, map[string]interface{}{
"sp1": sp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Backend.WaitStep(ctx, step, taskUUID)
}

302
pipeline/rpc/proto/traced/tracedwoodpeckerclient.gen.go Normal file
View file

@ -0,0 +1,302 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/pipeline/rpc/proto -i WoodpeckerClient -t ../../../../templates/opentelemetry.go.tpl -o tracedwoodpeckerclient.gen.go -l ""
import (
context "context"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/pipeline/rpc/proto"
grpc "google.golang.org/grpc"
)
// WoodpeckerClientWithTracing implements proto.WoodpeckerClient interface instrumented with opentracing spans
type WoodpeckerClientWithTracing struct {
proto.WoodpeckerClient
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewWoodpeckerClientWithTracing returns WoodpeckerClientWithTracing
func NewWoodpeckerClientWithTracing(base proto.WoodpeckerClient, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) WoodpeckerClientWithTracing {
d := WoodpeckerClientWithTracing{
WoodpeckerClient: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// Done implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Done(ctx context.Context, in *proto.DoneRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Done")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Done(ctx, in, opts...)
}
// Extend implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Extend(ctx context.Context, in *proto.ExtendRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Extend")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Extend(ctx, in, opts...)
}
// Init implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Init(ctx context.Context, in *proto.InitRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Init")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Init(ctx, in, opts...)
}
// Log implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Log(ctx context.Context, in *proto.LogRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Log")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Log(ctx, in, opts...)
}
// Next implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Next(ctx context.Context, in *proto.NextRequest, opts ...grpc.CallOption) (np1 *proto.NextResponse, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Next")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"np1": np1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Next(ctx, in, opts...)
}
// RegisterAgent implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) RegisterAgent(ctx context.Context, in *proto.RegisterAgentRequest, opts ...grpc.CallOption) (rp1 *proto.RegisterAgentResponse, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.RegisterAgent")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"rp1": rp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.RegisterAgent(ctx, in, opts...)
}
// ReportHealth implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) ReportHealth(ctx context.Context, in *proto.ReportHealthRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.ReportHealth")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.ReportHealth(ctx, in, opts...)
}
// UnregisterAgent implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) UnregisterAgent(ctx context.Context, in *proto.Empty, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.UnregisterAgent")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.UnregisterAgent(ctx, in, opts...)
}
// Update implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Update(ctx context.Context, in *proto.UpdateRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Update")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Update(ctx, in, opts...)
}
// Version implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Version(ctx context.Context, in *proto.Empty, opts ...grpc.CallOption) (vp1 *proto.VersionResponse, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Version")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"vp1": vp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Version(ctx, in, opts...)
}
// Wait implements proto.WoodpeckerClient
func (_d WoodpeckerClientWithTracing) Wait(ctx context.Context, in *proto.WaitRequest, opts ...grpc.CallOption) (ep1 *proto.Empty, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "proto.WoodpeckerClient.Wait")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"in": in,
"opts": opts}, map[string]interface{}{
"ep1": ep1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.WoodpeckerClient.Wait(ctx, in, opts...)
}

285
pipeline/rpc/traced/tracedpeer.gen.go Normal file
View file

@ -0,0 +1,285 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/pipeline/rpc -i Peer -t ../../../templates/opentelemetry.go.tpl -o tracedpeer.gen.go -l ""
import (
"context"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/pipeline/rpc"
)
// PeerWithTracing implements rpc.Peer interface instrumented with opentracing spans
type PeerWithTracing struct {
rpc.Peer
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewPeerWithTracing returns PeerWithTracing
func NewPeerWithTracing(base rpc.Peer, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) PeerWithTracing {
d := PeerWithTracing{
Peer: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// Done implements rpc.Peer
func (_d PeerWithTracing) Done(ctx context.Context, id string, state rpc.State) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Done")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id,
"state": state}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Done(ctx, id, state)
}
// Extend implements rpc.Peer
func (_d PeerWithTracing) Extend(ctx context.Context, id string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Extend")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Extend(ctx, id)
}
// Init implements rpc.Peer
func (_d PeerWithTracing) Init(ctx context.Context, id string, state rpc.State) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Init")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id,
"state": state}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Init(ctx, id, state)
}
// Log implements rpc.Peer
func (_d PeerWithTracing) Log(ctx context.Context, logEntry *rpc.LogEntry) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Log")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"logEntry": logEntry}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Log(ctx, logEntry)
}
// Next implements rpc.Peer
func (_d PeerWithTracing) Next(ctx context.Context, f rpc.Filter) (wp1 *rpc.Workflow, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Next")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"f": f}, map[string]interface{}{
"wp1": wp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Next(ctx, f)
}
// RegisterAgent implements rpc.Peer
func (_d PeerWithTracing) RegisterAgent(ctx context.Context, platform string, backend string, version string, capacity int) (i1 int64, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.RegisterAgent")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"platform": platform,
"backend": backend,
"version": version,
"capacity": capacity}, map[string]interface{}{
"i1": i1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.RegisterAgent(ctx, platform, backend, version, capacity)
}
// ReportHealth implements rpc.Peer
func (_d PeerWithTracing) ReportHealth(ctx context.Context) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.ReportHealth")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.ReportHealth(ctx)
}
// UnregisterAgent implements rpc.Peer
func (_d PeerWithTracing) UnregisterAgent(ctx context.Context) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.UnregisterAgent")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.UnregisterAgent(ctx)
}
// Update implements rpc.Peer
func (_d PeerWithTracing) Update(ctx context.Context, id string, state rpc.State) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Update")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id,
"state": state}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Update(ctx, id, state)
}
// Version implements rpc.Peer
func (_d PeerWithTracing) Version(ctx context.Context) (vp1 *rpc.Version, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Version")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx}, map[string]interface{}{
"vp1": vp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Version(ctx)
}
// Wait implements rpc.Peer
func (_d PeerWithTracing) Wait(ctx context.Context, id string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "rpc.Peer.Wait")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Peer.Wait(ctx, id)
}

64
server/cache/traced/tracedmembership.gen.go vendored Normal file
View file

@ -0,0 +1,64 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/server/cache -i MembershipService -t ../../../templates/opentelemetry.go.tpl -o tracedmembership.gen.go -l ""
import (
"context"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/server/cache"
"go.woodpecker-ci.org/woodpecker/v2/server/forge"
"go.woodpecker-ci.org/woodpecker/v2/server/model"
)
// MembershipServiceWithTracing implements cache.MembershipService interface instrumented with opentracing spans
type MembershipServiceWithTracing struct {
cache.MembershipService
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewMembershipServiceWithTracing returns MembershipServiceWithTracing
func NewMembershipServiceWithTracing(base cache.MembershipService, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) MembershipServiceWithTracing {
d := MembershipServiceWithTracing{
MembershipService: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// Get implements cache.MembershipService
func (_d MembershipServiceWithTracing) Get(ctx context.Context, _forge forge.Forge, u *model.User, org string) (op1 *model.OrgPerm, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "cache.MembershipService.Get")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"_forge": _forge,
"u": u,
"org": org}, map[string]interface{}{
"op1": op1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.MembershipService.Get(ctx, _forge, u, org)
}

22
server/forge/traced/forgerefresher.go Normal file
View file

@ -0,0 +1,22 @@
// Copyright 2024 Woodpecker Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package traced
import "go.woodpecker-ci.org/woodpecker/v2/server/forge"
type ForgeRefresher interface {
forge.Forge
forge.Refresher
}

432
server/forge/traced/tracedforge.gen.go Normal file
View file

@ -0,0 +1,432 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/server/forge -i Forge -t ../../../templates/opentelemetry.go.tpl -o tracedforge.gen.go -l ""
import (
"context"
"net/http"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/server/forge"
"go.woodpecker-ci.org/woodpecker/v2/server/forge/types"
"go.woodpecker-ci.org/woodpecker/v2/server/model"
)
// ForgeWithTracing implements forge.Forge interface instrumented with opentracing spans
type ForgeWithTracing struct {
forge.Forge
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewForgeWithTracing returns ForgeWithTracing
func NewForgeWithTracing(base forge.Forge, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) ForgeWithTracing {
d := ForgeWithTracing{
Forge: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// Activate implements forge.Forge
func (_d ForgeWithTracing) Activate(ctx context.Context, u *model.User, r *model.Repo, link string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Activate")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"link": link}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Activate(ctx, u, r, link)
}
// Auth implements forge.Forge
func (_d ForgeWithTracing) Auth(ctx context.Context, token string, secret string) (s1 string, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Auth")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"token": token,
"secret": secret}, map[string]interface{}{
"s1": s1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Auth(ctx, token, secret)
}
// BranchHead implements forge.Forge
func (_d ForgeWithTracing) BranchHead(ctx context.Context, u *model.User, r *model.Repo, branch string) (cp1 *model.Commit, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.BranchHead")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"branch": branch}, map[string]interface{}{
"cp1": cp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.BranchHead(ctx, u, r, branch)
}
// Branches implements forge.Forge
func (_d ForgeWithTracing) Branches(ctx context.Context, u *model.User, r *model.Repo, p *model.ListOptions) (sa1 []string, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Branches")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"p": p}, map[string]interface{}{
"sa1": sa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Branches(ctx, u, r, p)
}
// Deactivate implements forge.Forge
func (_d ForgeWithTracing) Deactivate(ctx context.Context, u *model.User, r *model.Repo, link string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Deactivate")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"link": link}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Deactivate(ctx, u, r, link)
}
// Dir implements forge.Forge
func (_d ForgeWithTracing) Dir(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, f string) (fpa1 []*types.FileMeta, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Dir")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"b": b,
"f": f}, map[string]interface{}{
"fpa1": fpa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Dir(ctx, u, r, b, f)
}
// File implements forge.Forge
func (_d ForgeWithTracing) File(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, f string) (ba1 []byte, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.File")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"b": b,
"f": f}, map[string]interface{}{
"ba1": ba1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.File(ctx, u, r, b, f)
}
// Hook implements forge.Forge
func (_d ForgeWithTracing) Hook(ctx context.Context, r *http.Request) (repo *model.Repo, pipeline *model.Pipeline, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Hook")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"r": r}, map[string]interface{}{
"repo": repo,
"pipeline": pipeline,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Hook(ctx, r)
}
// Login implements forge.Forge
func (_d ForgeWithTracing) Login(ctx context.Context, r *types.OAuthRequest) (up1 *model.User, s1 string, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Login")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"r": r}, map[string]interface{}{
"up1": up1,
"s1": s1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Login(ctx, r)
}
// Org implements forge.Forge
func (_d ForgeWithTracing) Org(ctx context.Context, u *model.User, org string) (op1 *model.Org, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Org")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"org": org}, map[string]interface{}{
"op1": op1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Org(ctx, u, org)
}
// OrgMembership implements forge.Forge
func (_d ForgeWithTracing) OrgMembership(ctx context.Context, u *model.User, org string) (op1 *model.OrgPerm, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.OrgMembership")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"org": org}, map[string]interface{}{
"op1": op1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.OrgMembership(ctx, u, org)
}
// PullRequests implements forge.Forge
func (_d ForgeWithTracing) PullRequests(ctx context.Context, u *model.User, r *model.Repo, p *model.ListOptions) (ppa1 []*model.PullRequest, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.PullRequests")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"p": p}, map[string]interface{}{
"ppa1": ppa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.PullRequests(ctx, u, r, p)
}
// Repo implements forge.Forge
func (_d ForgeWithTracing) Repo(ctx context.Context, u *model.User, remoteID model.ForgeRemoteID, owner string, name string) (rp1 *model.Repo, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Repo")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"remoteID": remoteID,
"owner": owner,
"name": name}, map[string]interface{}{
"rp1": rp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Repo(ctx, u, remoteID, owner, name)
}
// Repos implements forge.Forge
func (_d ForgeWithTracing) Repos(ctx context.Context, u *model.User) (rpa1 []*model.Repo, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Repos")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u}, map[string]interface{}{
"rpa1": rpa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Repos(ctx, u)
}
// Status implements forge.Forge
func (_d ForgeWithTracing) Status(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, p *model.Workflow) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Status")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"b": b,
"p": p}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Status(ctx, u, r, b, p)
}
// Teams implements forge.Forge
func (_d ForgeWithTracing) Teams(ctx context.Context, u *model.User) (tpa1 []*model.Team, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "forge.Forge.Teams")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u}, map[string]interface{}{
"tpa1": tpa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Forge.Teams(ctx, u)
}

454
server/forge/traced/tracedforgerefresher.gen.go Normal file
View file

@ -0,0 +1,454 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/server/forge/traced -i ForgeRefresher -t ../../../templates/opentelemetry.go.tpl -o tracedforgerefresher.gen.go -l ""
import (
"context"
"net/http"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/server/forge/types"
"go.woodpecker-ci.org/woodpecker/v2/server/model"
)
// ForgeRefresherWithTracing implements ForgeRefresher interface instrumented with opentracing spans
type ForgeRefresherWithTracing struct {
ForgeRefresher
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewForgeRefresherWithTracing returns ForgeRefresherWithTracing
func NewForgeRefresherWithTracing(base ForgeRefresher, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) ForgeRefresherWithTracing {
d := ForgeRefresherWithTracing{
ForgeRefresher: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// Activate implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Activate(ctx context.Context, u *model.User, r *model.Repo, link string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Activate")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"link": link}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Activate(ctx, u, r, link)
}
// Auth implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Auth(ctx context.Context, token string, secret string) (s1 string, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Auth")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"token": token,
"secret": secret}, map[string]interface{}{
"s1": s1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Auth(ctx, token, secret)
}
// BranchHead implements ForgeRefresher
func (_d ForgeRefresherWithTracing) BranchHead(ctx context.Context, u *model.User, r *model.Repo, branch string) (cp1 *model.Commit, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.BranchHead")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"branch": branch}, map[string]interface{}{
"cp1": cp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.BranchHead(ctx, u, r, branch)
}
// Branches implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Branches(ctx context.Context, u *model.User, r *model.Repo, p *model.ListOptions) (sa1 []string, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Branches")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"p": p}, map[string]interface{}{
"sa1": sa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Branches(ctx, u, r, p)
}
// Deactivate implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Deactivate(ctx context.Context, u *model.User, r *model.Repo, link string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Deactivate")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"link": link}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Deactivate(ctx, u, r, link)
}
// Dir implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Dir(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, f string) (fpa1 []*types.FileMeta, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Dir")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"b": b,
"f": f}, map[string]interface{}{
"fpa1": fpa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Dir(ctx, u, r, b, f)
}
// File implements ForgeRefresher
func (_d ForgeRefresherWithTracing) File(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, f string) (ba1 []byte, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.File")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"b": b,
"f": f}, map[string]interface{}{
"ba1": ba1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.File(ctx, u, r, b, f)
}
// Hook implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Hook(ctx context.Context, r *http.Request) (repo *model.Repo, pipeline *model.Pipeline, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Hook")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"r": r}, map[string]interface{}{
"repo": repo,
"pipeline": pipeline,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Hook(ctx, r)
}
// Login implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Login(ctx context.Context, r *types.OAuthRequest) (up1 *model.User, s1 string, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Login")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"r": r}, map[string]interface{}{
"up1": up1,
"s1": s1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Login(ctx, r)
}
// Org implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Org(ctx context.Context, u *model.User, org string) (op1 *model.Org, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Org")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"org": org}, map[string]interface{}{
"op1": op1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Org(ctx, u, org)
}
// OrgMembership implements ForgeRefresher
func (_d ForgeRefresherWithTracing) OrgMembership(ctx context.Context, u *model.User, org string) (op1 *model.OrgPerm, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.OrgMembership")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"org": org}, map[string]interface{}{
"op1": op1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.OrgMembership(ctx, u, org)
}
// PullRequests implements ForgeRefresher
func (_d ForgeRefresherWithTracing) PullRequests(ctx context.Context, u *model.User, r *model.Repo, p *model.ListOptions) (ppa1 []*model.PullRequest, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.PullRequests")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"p": p}, map[string]interface{}{
"ppa1": ppa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.PullRequests(ctx, u, r, p)
}
// Refresh implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Refresh(ctx context.Context, up1 *model.User) (b1 bool, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Refresh")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"up1": up1}, map[string]interface{}{
"b1": b1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Refresh(ctx, up1)
}
// Repo implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Repo(ctx context.Context, u *model.User, remoteID model.ForgeRemoteID, owner string, name string) (rp1 *model.Repo, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Repo")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"remoteID": remoteID,
"owner": owner,
"name": name}, map[string]interface{}{
"rp1": rp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Repo(ctx, u, remoteID, owner, name)
}
// Repos implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Repos(ctx context.Context, u *model.User) (rpa1 []*model.Repo, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Repos")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u}, map[string]interface{}{
"rpa1": rpa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Repos(ctx, u)
}
// Status implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Status(ctx context.Context, u *model.User, r *model.Repo, b *model.Pipeline, p *model.Workflow) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Status")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u,
"r": r,
"b": b,
"p": p}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Status(ctx, u, r, b, p)
}
// Teams implements ForgeRefresher
func (_d ForgeRefresherWithTracing) Teams(ctx context.Context, u *model.User) (tpa1 []*model.Team, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "ForgeRefresher.Teams")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"u": u}, map[string]interface{}{
"tpa1": tpa1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.ForgeRefresher.Teams(ctx, u)
}

277
server/queue/traced/tracedqueue.gen.go Normal file
View file

@ -0,0 +1,277 @@
// Code generated by gowrap. DO NOT EDIT.
// template: ../../../templates/opentelemetry.go.tpl
// gowrap: http://github.com/hexdigest/gowrap
package traced
//go:generate gowrap gen -p go.woodpecker-ci.org/woodpecker/v2/server/queue -i Queue -t ../../../templates/opentelemetry.go.tpl -o tracedqueue.gen.go -l ""
import (
"context"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
"go.woodpecker-ci.org/woodpecker/v2/server/model"
"go.woodpecker-ci.org/woodpecker/v2/server/queue"
)
// QueueWithTracing implements queue.Queue interface instrumented with opentracing spans
type QueueWithTracing struct {
queue.Queue
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// NewQueueWithTracing returns QueueWithTracing
func NewQueueWithTracing(base queue.Queue, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) QueueWithTracing {
d := QueueWithTracing{
Queue: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
// Done implements queue.Queue
func (_d QueueWithTracing) Done(ctx context.Context, id string, exitStatus model.StatusValue) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Done")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id,
"exitStatus": exitStatus}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Done(ctx, id, exitStatus)
}
// Error implements queue.Queue
func (_d QueueWithTracing) Error(ctx context.Context, id string, e1 error) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Error")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id,
"e1": e1}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Error(ctx, id, e1)
}
// ErrorAtOnce implements queue.Queue
func (_d QueueWithTracing) ErrorAtOnce(ctx context.Context, ids []string, e1 error) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.ErrorAtOnce")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"ids": ids,
"e1": e1}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.ErrorAtOnce(ctx, ids, e1)
}
// Evict implements queue.Queue
func (_d QueueWithTracing) Evict(ctx context.Context, id string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Evict")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Evict(ctx, id)
}
// EvictAtOnce implements queue.Queue
func (_d QueueWithTracing) EvictAtOnce(ctx context.Context, ids []string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.EvictAtOnce")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"ids": ids}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.EvictAtOnce(ctx, ids)
}
// Extend implements queue.Queue
func (_d QueueWithTracing) Extend(ctx context.Context, id string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Extend")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Extend(ctx, id)
}
// Info implements queue.Queue
func (_d QueueWithTracing) Info(ctx context.Context) (i1 queue.InfoT) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Info")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx}, map[string]interface{}{
"i1": i1})
}
_span.End()
}()
return _d.Queue.Info(ctx)
}
// Poll implements queue.Queue
func (_d QueueWithTracing) Poll(ctx context.Context, agentID int64, f queue.FilterFn) (tp1 *model.Task, err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Poll")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"agentID": agentID,
"f": f}, map[string]interface{}{
"tp1": tp1,
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Poll(ctx, agentID, f)
}
// Push implements queue.Queue
func (_d QueueWithTracing) Push(ctx context.Context, task *model.Task) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Push")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"task": task}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Push(ctx, task)
}
// PushAtOnce implements queue.Queue
func (_d QueueWithTracing) PushAtOnce(ctx context.Context, tasks []*model.Task) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.PushAtOnce")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"tasks": tasks}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.PushAtOnce(ctx, tasks)
}
// Wait implements queue.Queue
func (_d QueueWithTracing) Wait(ctx context.Context, id string) (err error) {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "queue.Queue.Wait")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"id": id}, map[string]interface{}{
"err": err})
} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
_span.End()
}()
return _d.Queue.Wait(ctx, id)
}

53
templates/opentelemetry.go.tpl Normal file
View file

@ -0,0 +1,53 @@
{{.Import}}
import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
)
{{ $decorator := (or .Vars.DecoratorName (printf "%sWithTracing" .Interface.Name)) }}
// {{$decorator}} implements {{.Interface.Type}} interface instrumented with opentracing spans
type {{$decorator}} struct {
{{.Interface.Type}}
_instance string
_spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// New{{$decorator}} returns {{$decorator}}
func New{{$decorator}} (base {{.Interface.Type}}, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) {{$decorator}} {
d := {{$decorator}} {
{{.Interface.Name}}: base,
_instance: instance,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
d._spanDecorator = spanDecorator[0]
}
return d
}
{{range $method := .Interface.Methods}}
{{if $method.AcceptsContext}}
// {{$method.Name}} implements {{$.Interface.Type}}
func (_d {{$decorator}}) {{$method.Declaration}} {
ctx, _span := otel.Tracer(_d._instance).Start(ctx, "{{$.Interface.Type}}.{{$method.Name}}")
defer func() {
if _d._spanDecorator != nil {
_d._spanDecorator(_span, {{$method.ParamsMap}}, {{$method.ResultsMap}})
}{{- if $method.ReturnsError}} else if err != nil {
_span.RecordError(err)
_span.SetAttributes(
attribute.String("event", "error"),
attribute.String("message", err.Error()),
)
}
{{end}}
_span.End()
}()
{{$method.Pass (printf "_d.%s." $.Interface.Name) }}
}
{{end}}
{{end}}