github.com/MetalBlockchain/metalgo@v1.11.9/snow/networking/sender/traced_sender.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package sender
     5  
     6  import (
     7  	"context"
     8  
     9  	"go.opentelemetry.io/otel/attribute"
    10  
    11  	"github.com/MetalBlockchain/metalgo/ids"
    12  	"github.com/MetalBlockchain/metalgo/snow/engine/common"
    13  	"github.com/MetalBlockchain/metalgo/trace"
    14  	"github.com/MetalBlockchain/metalgo/utils/set"
    15  
    16  	oteltrace "go.opentelemetry.io/otel/trace"
    17  )
    18  
    19  var _ common.Sender = (*tracedSender)(nil)
    20  
    21  type tracedSender struct {
    22  	sender common.Sender
    23  	tracer trace.Tracer
    24  }
    25  
    26  func Trace(sender common.Sender, tracer trace.Tracer) common.Sender {
    27  	return &tracedSender{
    28  		sender: sender,
    29  		tracer: tracer,
    30  	}
    31  }
    32  
    33  func (s *tracedSender) SendGetStateSummaryFrontier(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32) {
    34  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendGetStateSummaryFrontier", oteltrace.WithAttributes(
    35  		attribute.Int64("requestID", int64(requestID)),
    36  	))
    37  	defer span.End()
    38  
    39  	s.sender.SendGetStateSummaryFrontier(ctx, nodeIDs, requestID)
    40  }
    41  
    42  func (s *tracedSender) SendStateSummaryFrontier(ctx context.Context, nodeID ids.NodeID, requestID uint32, summary []byte) {
    43  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendStateSummaryFrontier", oteltrace.WithAttributes(
    44  		attribute.Stringer("recipients", nodeID),
    45  		attribute.Int64("requestID", int64(requestID)),
    46  		attribute.Int("summaryLen", len(summary)),
    47  	))
    48  	defer span.End()
    49  
    50  	s.sender.SendStateSummaryFrontier(ctx, nodeID, requestID, summary)
    51  }
    52  
    53  func (s *tracedSender) SendGetAcceptedStateSummary(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, heights []uint64) {
    54  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendGetAcceptedStateSummary", oteltrace.WithAttributes(
    55  		attribute.Int64("requestID", int64(requestID)),
    56  		attribute.Int("numHeights", len(heights)),
    57  	))
    58  	defer span.End()
    59  
    60  	s.sender.SendGetAcceptedStateSummary(ctx, nodeIDs, requestID, heights)
    61  }
    62  
    63  func (s *tracedSender) SendAcceptedStateSummary(ctx context.Context, nodeID ids.NodeID, requestID uint32, summaryIDs []ids.ID) {
    64  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendAcceptedStateSummary", oteltrace.WithAttributes(
    65  		attribute.Stringer("recipients", nodeID),
    66  		attribute.Int64("requestID", int64(requestID)),
    67  		attribute.Int("numSummaryIDs", len(summaryIDs)),
    68  	))
    69  	defer span.End()
    70  
    71  	s.sender.SendAcceptedStateSummary(ctx, nodeID, requestID, summaryIDs)
    72  }
    73  
    74  func (s *tracedSender) SendGetAcceptedFrontier(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32) {
    75  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendGetAcceptedFrontier", oteltrace.WithAttributes(
    76  		attribute.Int64("requestID", int64(requestID)),
    77  	))
    78  	defer span.End()
    79  
    80  	s.sender.SendGetAcceptedFrontier(ctx, nodeIDs, requestID)
    81  }
    82  
    83  func (s *tracedSender) SendAcceptedFrontier(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) {
    84  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendAcceptedFrontier", oteltrace.WithAttributes(
    85  		attribute.Stringer("recipients", nodeID),
    86  		attribute.Int64("requestID", int64(requestID)),
    87  		attribute.Stringer("containerID", containerID),
    88  	))
    89  	defer span.End()
    90  
    91  	s.sender.SendAcceptedFrontier(ctx, nodeID, requestID, containerID)
    92  }
    93  
    94  func (s *tracedSender) SendGetAccepted(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, containerIDs []ids.ID) {
    95  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendGetAccepted", oteltrace.WithAttributes(
    96  		attribute.Int64("requestID", int64(requestID)),
    97  		attribute.Int("numContainerIDs", len(containerIDs)),
    98  	))
    99  	defer span.End()
   100  
   101  	s.sender.SendGetAccepted(ctx, nodeIDs, requestID, containerIDs)
   102  }
   103  
   104  func (s *tracedSender) SendAccepted(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerIDs []ids.ID) {
   105  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendAccepted", oteltrace.WithAttributes(
   106  		attribute.Stringer("recipients", nodeID),
   107  		attribute.Int64("requestID", int64(requestID)),
   108  		attribute.Int("numContainerIDs", len(containerIDs)),
   109  	))
   110  	defer span.End()
   111  
   112  	s.sender.SendAccepted(ctx, nodeID, requestID, containerIDs)
   113  }
   114  
   115  func (s *tracedSender) SendGetAncestors(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) {
   116  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendGetAncestors", oteltrace.WithAttributes(
   117  		attribute.Stringer("recipients", nodeID),
   118  		attribute.Int64("requestID", int64(requestID)),
   119  		attribute.Stringer("containerID", containerID),
   120  	))
   121  	defer span.End()
   122  
   123  	s.sender.SendGetAncestors(ctx, nodeID, requestID, containerID)
   124  }
   125  
   126  func (s *tracedSender) SendAncestors(ctx context.Context, nodeID ids.NodeID, requestID uint32, containers [][]byte) {
   127  	_, span := s.tracer.Start(ctx, "tracedSender.SendAncestors", oteltrace.WithAttributes(
   128  		attribute.Stringer("recipients", nodeID),
   129  		attribute.Int64("requestID", int64(requestID)),
   130  		attribute.Int("numContainers", len(containers)),
   131  	))
   132  	defer span.End()
   133  
   134  	s.sender.SendAncestors(ctx, nodeID, requestID, containers)
   135  }
   136  
   137  func (s *tracedSender) SendGet(ctx context.Context, nodeID ids.NodeID, requestID uint32, containerID ids.ID) {
   138  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendGet", oteltrace.WithAttributes(
   139  		attribute.Stringer("recipients", nodeID),
   140  		attribute.Int64("requestID", int64(requestID)),
   141  		attribute.Stringer("containerID", containerID),
   142  	))
   143  	defer span.End()
   144  
   145  	s.sender.SendGet(ctx, nodeID, requestID, containerID)
   146  }
   147  
   148  func (s *tracedSender) SendPut(ctx context.Context, nodeID ids.NodeID, requestID uint32, container []byte) {
   149  	_, span := s.tracer.Start(ctx, "tracedSender.SendPut", oteltrace.WithAttributes(
   150  		attribute.Stringer("recipients", nodeID),
   151  		attribute.Int64("requestID", int64(requestID)),
   152  		attribute.Int("containerLen", len(container)),
   153  	))
   154  	defer span.End()
   155  
   156  	s.sender.SendPut(ctx, nodeID, requestID, container)
   157  }
   158  
   159  func (s *tracedSender) SendPushQuery(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, container []byte, requestedHeight uint64) {
   160  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendPushQuery", oteltrace.WithAttributes(
   161  		attribute.Int64("requestID", int64(requestID)),
   162  		attribute.Int("containerLen", len(container)),
   163  		attribute.Int64("requestedHeight", int64(requestedHeight)),
   164  	))
   165  	defer span.End()
   166  
   167  	s.sender.SendPushQuery(ctx, nodeIDs, requestID, container, requestedHeight)
   168  }
   169  
   170  func (s *tracedSender) SendPullQuery(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, containerID ids.ID, requestedHeight uint64) {
   171  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendPullQuery", oteltrace.WithAttributes(
   172  		attribute.Int64("requestID", int64(requestID)),
   173  		attribute.Stringer("containerID", containerID),
   174  		attribute.Int64("requestedHeight", int64(requestedHeight)),
   175  	))
   176  	defer span.End()
   177  
   178  	s.sender.SendPullQuery(ctx, nodeIDs, requestID, containerID, requestedHeight)
   179  }
   180  
   181  func (s *tracedSender) SendChits(ctx context.Context, nodeID ids.NodeID, requestID uint32, preferredID ids.ID, preferredIDAtHeight ids.ID, acceptedID ids.ID) {
   182  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendChits", oteltrace.WithAttributes(
   183  		attribute.Stringer("recipients", nodeID),
   184  		attribute.Int64("requestID", int64(requestID)),
   185  		attribute.Stringer("preferredID", preferredID),
   186  		attribute.Stringer("preferredIDAtHeight", preferredIDAtHeight),
   187  		attribute.Stringer("acceptedID", acceptedID),
   188  	))
   189  	defer span.End()
   190  
   191  	s.sender.SendChits(ctx, nodeID, requestID, preferredID, preferredIDAtHeight, acceptedID)
   192  }
   193  
   194  func (s *tracedSender) SendCrossChainAppRequest(ctx context.Context, chainID ids.ID, requestID uint32, appRequestBytes []byte) error {
   195  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendCrossChainAppRequest", oteltrace.WithAttributes(
   196  		attribute.Stringer("chainID", chainID),
   197  		attribute.Int64("requestID", int64(requestID)),
   198  		attribute.Int("requestLen", len(appRequestBytes)),
   199  	))
   200  	defer span.End()
   201  
   202  	return s.sender.SendCrossChainAppRequest(ctx, chainID, requestID, appRequestBytes)
   203  }
   204  
   205  func (s *tracedSender) SendCrossChainAppResponse(ctx context.Context, chainID ids.ID, requestID uint32, appResponseBytes []byte) error {
   206  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendCrossChainAppResponse", oteltrace.WithAttributes(
   207  		attribute.Stringer("chainID", chainID),
   208  		attribute.Int64("requestID", int64(requestID)),
   209  		attribute.Int("responseLen", len(appResponseBytes)),
   210  	))
   211  	defer span.End()
   212  
   213  	return s.sender.SendCrossChainAppResponse(ctx, chainID, requestID, appResponseBytes)
   214  }
   215  
   216  func (s *tracedSender) SendCrossChainAppError(ctx context.Context, chainID ids.ID, requestID uint32, errorCode int32, errorMessage string) error {
   217  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendCrossChainAppError", oteltrace.WithAttributes(
   218  		attribute.Stringer("chainID", chainID),
   219  		attribute.Int64("requestID", int64(requestID)),
   220  		attribute.Int64("errorCode", int64(errorCode)),
   221  		attribute.String("errorMessage", errorMessage),
   222  	))
   223  	defer span.End()
   224  
   225  	return s.sender.SendCrossChainAppError(ctx, chainID, requestID, errorCode, errorMessage)
   226  }
   227  
   228  func (s *tracedSender) SendAppRequest(ctx context.Context, nodeIDs set.Set[ids.NodeID], requestID uint32, appRequestBytes []byte) error {
   229  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendAppRequest", oteltrace.WithAttributes(
   230  		attribute.Int64("requestID", int64(requestID)),
   231  		attribute.Int("requestLen", len(appRequestBytes)),
   232  	))
   233  	defer span.End()
   234  
   235  	return s.sender.SendAppRequest(ctx, nodeIDs, requestID, appRequestBytes)
   236  }
   237  
   238  func (s *tracedSender) SendAppResponse(ctx context.Context, nodeID ids.NodeID, requestID uint32, appResponseBytes []byte) error {
   239  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendAppResponse", oteltrace.WithAttributes(
   240  		attribute.Stringer("recipients", nodeID),
   241  		attribute.Int64("requestID", int64(requestID)),
   242  		attribute.Int("responseLen", len(appResponseBytes)),
   243  	))
   244  	defer span.End()
   245  
   246  	return s.sender.SendAppResponse(ctx, nodeID, requestID, appResponseBytes)
   247  }
   248  
   249  func (s *tracedSender) SendAppError(ctx context.Context, nodeID ids.NodeID, requestID uint32, errorCode int32, errorMessage string) error {
   250  	ctx, span := s.tracer.Start(ctx, "tracedSender.SendAppError", oteltrace.WithAttributes(
   251  		attribute.Stringer("nodeID", nodeID),
   252  		attribute.Int64("requestID", int64(requestID)),
   253  		attribute.Int64("errorCode", int64(errorCode)),
   254  		attribute.String("errorMessage", errorMessage),
   255  	))
   256  	defer span.End()
   257  
   258  	return s.sender.SendAppError(ctx, nodeID, requestID, errorCode, errorMessage)
   259  }
   260  
   261  func (s *tracedSender) SendAppGossip(
   262  	ctx context.Context,
   263  	config common.SendConfig,
   264  	appGossipBytes []byte,
   265  ) error {
   266  	_, span := s.tracer.Start(ctx, "tracedSender.SendAppGossip", oteltrace.WithAttributes(
   267  		attribute.Int("numNodeIDs", config.NodeIDs.Len()),
   268  		attribute.Int("numValidators", config.Validators),
   269  		attribute.Int("numNonValidators", config.NonValidators),
   270  		attribute.Int("numPeers", config.Peers),
   271  		attribute.Int("gossipLen", len(appGossipBytes)),
   272  	))
   273  	defer span.End()
   274  
   275  	return s.sender.SendAppGossip(
   276  		ctx,
   277  		config,
   278  		appGossipBytes,
   279  	)
   280  }