miner, consensus, eth/catalyst: pass pointer to error to spanEnd

consensus/beacon/consensus.go

@@ -351,12 +351,10 @@ func (beacon *Beacon) FinalizeAndAssemble(ctx context.Context, chain consensus.C
 		telemetry.Int64Attribute("txs.count", int64(len(body.Transactions))),
 		telemetry.Int64Attribute("withdrawals.count", int64(len(body.Withdrawals))),
 	)
-	defer spanEnd(err)
+	defer spanEnd(&err)
 
 	if !beacon.IsPoSHeader(header) {
-		_, _, delegateEnd := telemetry.StartSpan(ctx, "consensus.beacon.delegateFinalizeAndAssemble")
 		block, delegateErr := beacon.ethone.FinalizeAndAssemble(ctx, chain, header, state, body, receipts)
-		delegateEnd(delegateErr)
 		return block, delegateErr
 	}
 	shanghai := chain.Config().IsShanghai(header.Number, header.Time)
@@ -372,19 +370,19 @@ func (beacon *Beacon) FinalizeAndAssemble(ctx context.Context, chain consensus.C
 		}
 	}
 	// Finalize and assemble the block.
-	_, _, finalizeEnd := telemetry.StartSpan(ctx, "consensus.beacon.Finalize")
+	_, _, finalizeSpanEnd := telemetry.StartSpan(ctx, "consensus.beacon.Finalize")
 	beacon.Finalize(chain, header, state, body)
-	finalizeEnd(nil)
+	finalizeSpanEnd(nil)
 
 	// Assign the final state root to header.
-	_, _, rootEnd := telemetry.StartSpan(ctx, "consensus.beacon.IntermediateRoot")
+	_, _, rootSpanEnd := telemetry.StartSpan(ctx, "consensus.beacon.IntermediateRoot")
 	header.Root = state.IntermediateRoot(true)
-	rootEnd(nil)
+	rootSpanEnd(nil)
 
 	// Assemble the final block.
-	_, _, blockEnd := telemetry.StartSpan(ctx, "consensus.beacon.NewBlock")
+	_, _, blockSpanEnd := telemetry.StartSpan(ctx, "consensus.beacon.NewBlock")
 	block := types.NewBlock(header, body, receipts, trie.NewStackTrie(nil))
-	blockEnd(nil)
+	blockSpanEnd(nil)
 	return block, nil
 }
 

eth/catalyst/api.go

@@ -213,7 +213,7 @@ func (api *ConsensusAPI) ForkchoiceUpdatedV3(ctx context.Context, update engine.
 
 func (api *ConsensusAPI) forkchoiceUpdated(ctx context.Context, update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes, payloadVersion engine.PayloadVersion, payloadWitness bool) (result engine.ForkChoiceResponse, err error) {
 	ctx, _, spanEnd := telemetry.StartSpan(ctx, "engine.forkchoiceUpdated")
-	defer spanEnd(err)
+	defer spanEnd(&err)
 	api.forkchoiceLock.Lock()
 	defer api.forkchoiceLock.Unlock()
 

eth/catalyst/simulated_beacon.go

@@ -212,7 +212,7 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u
 		Random:                random,
 		BeaconRoot:            &common.Hash{},
 	}, version, false)
-	fcSpanEnd(err)
+	fcSpanEnd(&err)
 	if err != nil {
 		return err
 	}
@@ -234,7 +234,7 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u
 		Method:  "getPayloadV" + fmt.Sprintf("%d", version),
 	})
 	envelope, err := c.engineAPI.getPayload(*fcResponse.PayloadID, true, nil, nil)
-	gpSpanEnd(err)
+	gpSpanEnd(&err)
 	if err != nil {
 		return err
 	}
@@ -283,7 +283,7 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u
 		Method:  "newPayloadV" + fmt.Sprintf("%d", version),
 	})
 	_, err = c.engineAPI.newPayload(*payload, blobHashes, beaconRoot, requests, false)
-	npSpanEnd(err)
+	npSpanEnd(&err)
 	if err != nil {
 		return err
 	}
@@ -297,7 +297,7 @@ func (c *SimulatedBeacon) sealBlock(withdrawals []*types.Withdrawal, timestamp u
 		Method:  "forkchoiceUpdatedV" + fmt.Sprintf("%d", version),
 	})
 	_, err = c.engineAPI.forkchoiceUpdated(fcuCtx, c.curForkchoiceState, nil, version, false)
-	fcuSpanEnd(err)
+	fcuSpanEnd(&err)
 	if err != nil {
 		return err
 	}

miner/payload_building.go

@@ -210,6 +210,24 @@ func (payload *Payload) ResolveFull() *engine.ExecutionPayloadEnvelope {
 	return envelope
 }
 
+func (miner *Miner) runBuildIteration(ctx context.Context, iteration int, payload *Payload, params *generateParams, witness bool) {
+	ctx, span, spanEnd := telemetry.StartSpan(ctx, "miner.buildIteration",
+		telemetry.Int64Attribute("iteration", int64(iteration)),
+	)
+	var err error
+	defer spanEnd(&err)
+
+	start := time.Now()
+	r := miner.generateWork(ctx, params, witness)
+	err = r.err
+	if err == nil {
+		accepted := payload.update(r, time.Since(start))
+		span.SetAttributes(telemetry.BoolAttribute("update.accepted", accepted))
+	} else {
+		log.Info("Error while generating work", "id", payload.id, "err", err)
+	}
+}
+
 // buildPayload builds the payload according to the provided parameters.
 func (miner *Miner) buildPayload(ctx context.Context, args *BuildPayloadArgs, witness bool) (result *Payload, err error) {
 	payloadID := args.Id()
@@ -218,7 +236,7 @@ func (miner *Miner) buildPayload(ctx context.Context, args *BuildPayloadArgs, wi
 		telemetry.StringAttribute("parent.hash", args.Parent.String()),
 		telemetry.Int64Attribute("timestamp", int64(args.Timestamp)),
 	)
-	defer spanEnd(err)
+	defer spanEnd(&err)
 
 	// Build the initial version with no transaction included. It should be fast
 	// enough to run. The empty payload can at least make sure there is something
@@ -272,23 +290,11 @@ func (miner *Miner) buildPayload(ctx context.Context, args *BuildPayloadArgs, wi
 			beaconRoot:  args.BeaconRoot,
 			noTxs:       false,
 		}
-
 		for {
 			select {
 			case <-timer.C:
 				iteration++
-				iterCtx, iterSpan, iterSpanEnd := telemetry.StartSpan(bCtx, "miner.buildIteration",
+				miner.runBuildIteration(bCtx, iteration, payload, fullParams, witness)
-					telemetry.Int64Attribute("iteration", int64(iteration)),
-				)
-				start := time.Now()
-				r := miner.generateWork(iterCtx, fullParams, witness)
-				if r.err == nil {
-					accepted := payload.update(r, time.Since(start))
-					iterSpan.SetAttributes(telemetry.BoolAttribute("update.accepted", accepted))
-				} else {
-					log.Info("Error while generating work", "id", payload.id, "err", r.err)
-				}
-				iterSpanEnd(r.err)
 				timer.Reset(miner.config.Recommit)
 			case <-payload.stop:
 				payload.lock.Lock()

miner/worker.go

@@ -128,7 +128,7 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams,
 			)
 		}
 		if result != nil {
-			spanEnd(result.err)
+			spanEnd(&result.err)
 		} else {
 			spanEnd(nil)
 		}
@@ -191,7 +191,7 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams,
 
 	ctx, _, finalizeSpanEnd := telemetry.StartSpan(ctx, "miner.FinalizeAndAssemble")
 	block, err := miner.engine.FinalizeAndAssemble(ctx, miner.chain, work.header, work.state, &body, work.receipts)
-	finalizeSpanEnd(err)
+	finalizeSpanEnd(&err)
 	if err != nil {
 		return &newPayloadResult{err: err}
 	}
@@ -211,7 +211,7 @@ func (miner *Miner) generateWork(ctx context.Context, genParam *generateParams,
 // the pending transactions are not filled yet, only the empty task returned.
 func (miner *Miner) prepareWork(ctx context.Context, genParams *generateParams, witness bool) (result *environment, err error) {
 	_, _, spanEnd := telemetry.StartSpan(ctx, "miner.prepareWork")
-	defer spanEnd(err)
+	defer spanEnd(&err)
 	miner.confMu.RLock()
 	defer miner.confMu.RUnlock()
 
@@ -318,7 +318,7 @@ func (miner *Miner) makeEnv(parent *types.Header, header *types.Header, coinbase
 
 func (miner *Miner) commitTransaction(ctx context.Context, env *environment, tx *types.Transaction) (err error) {
 	_, _, spanEnd := telemetry.StartSpan(ctx, "miner.commitTransaction")
-	defer spanEnd(err)
+	defer spanEnd(&err)
 	if tx.Type() == types.BlobTxType {
 		return miner.commitBlobTransaction(env, tx)
 	}
@@ -499,7 +499,7 @@ func (miner *Miner) commitTransactions(ctx context.Context, env *environment, pl
 // be customized with the plugin in the future.
 func (miner *Miner) fillTransactions(ctx context.Context, interrupt *atomic.Int32, env *environment) (err error) {
 	ctx, span, spanEnd := telemetry.StartSpan(ctx, "miner.fillTransactions")
-	defer spanEnd(err)
+	defer spanEnd(&err)
 	miner.confMu.RLock()
 	tip := miner.config.GasPrice
 	prio := miner.prio