Give SQL transactions a debug name

client/client_test.go

@@ -485,7 +485,7 @@ func concurrentIncrements(db *client.DB, t *testing.T) {
 			wgStart.Wait()
 
 			if err := db.Txn(func(txn *client.Txn) error {
-				txn.SetDebugName(fmt.Sprintf("test-%d", i))
+				txn.SetDebugName(fmt.Sprintf("test-%d", i), 0)
 
 				// Retrieve the other key.
 				gr, err := txn.Get(readKey)

client/db.go

@@ -416,7 +416,9 @@ func (db *DB) Run(b *Batch) error {
 //
 // TODO(pmattis): Allow transaction options to be specified.
 func (db *DB) Txn(retryable func(txn *Txn) error) error {
-	return newTxn(*db).exec(retryable)
+	txn := NewTxn(*db)
+	txn.SetDebugName("", 1)
+	return txn.exec(retryable)
 }
 
 // send runs the specified calls synchronously in a single batch and

client/db_test.go

@@ -349,7 +349,6 @@ func TestCommonMethods(t *testing.T) {
 		key{dbType, "Run"}:                   {},
 		key{dbType, "Txn"}:                   {},
 		key{txnType, "CommitInBatch"}:        {},
-		key{txnType, "ToProto"}:              {},
 		key{txnType, "Commit"}:               {},
 		key{txnType, "Rollback"}:             {},
 		key{txnType, "DebugName"}:            {},

client/txn.go

@@ -48,15 +48,15 @@ type txnSender Txn
 
 func (ts *txnSender) Send(ctx context.Context, call proto.Call) {
 	// Send call through wrapped sender.
-	call.Args.Header().Txn = &ts.txn
+	call.Args.Header().Txn = &ts.Proto
 	ts.wrapped.Send(ctx, call)
-	ts.txn.Update(call.Reply.Header().Txn)
+	ts.Proto.Update(call.Reply.Header().Txn)
 
 	if err, ok := call.Reply.Header().GoError().(*proto.TransactionAbortedError); ok {
 		// On Abort, reset the transaction so we start anew on restart.
-		ts.txn = proto.Transaction{
-			Name:      ts.txn.Name,
-			Isolation: ts.txn.Isolation,
+		ts.Proto = proto.Transaction{
+			Name:      ts.Proto.Name,
+			Isolation: ts.Proto.Isolation,
 			Priority:  err.Txn.Priority, // acts as a minimum priority on restart
 		}
 	}
@@ -67,7 +67,7 @@ func (ts *txnSender) Send(ctx context.Context, call proto.Call) {
 type Txn struct {
 	db      DB
 	wrapped Sender
-	txn     proto.Transaction
+	Proto   proto.Transaction
 	// haveTxnWrite is true as soon as the current attempt contains a write
 	// (prior to sending). This is in contrast to txn.Writing, which is set
 	// by the coordinator when the first intent has been created, and which
@@ -78,49 +78,31 @@ type Txn struct {
 	haveEndTxn   bool // True if there was an explicit EndTransaction
 }
 
-func newTxn(db DB) *Txn {
+// NewTxn returns a new txn.
+func NewTxn(db DB) *Txn {
 	txn := &Txn{
 		db:      db,
 		wrapped: db.Sender,
 	}
 	txn.db.Sender = (*txnSender)(txn)
-
-	// Caller's caller.
-	file, line, fun := caller.Lookup(2)
-	txn.txn.Name = fmt.Sprintf("%s:%d %s", file, line, fun)
 	return txn
 }
 
-// NewTxn returns a new txn.
-func NewTxn(db DB) *Txn {
-	return newTxn(db)
-}
-
-// NewTxnFromProto returns a transaction created from the preserved
-// state.
-func NewTxnFromProto(db DB, state proto.Transaction) *Txn {
-	txn := newTxn(db)
-	txn.txn = state
-	return txn
-}
-
-// ToProto returns the transaction state in a protobuf.
-func (txn *Txn) ToProto() proto.Transaction {
-	return txn.txn
-}
-
 // SetDebugName sets the debug name associated with the transaction which will
 // appear in log files and the web UI. Each transaction starts out with an
 // automatically assigned debug name composed of the file and line number where
 // the transaction was created.
-func (txn *Txn) SetDebugName(name string) {
-	file, line, _ := caller.Lookup(1)
-	txn.txn.Name = fmt.Sprintf("%s:%d %s", file, line, name)
+func (txn *Txn) SetDebugName(name string, depth int) {
+	file, line, fun := caller.Lookup(depth + 1)
+	if name == "" {
+		name = fun
+	}
+	txn.Proto.Name = fmt.Sprintf("%s:%d %s", file, line, name)
 }
 
 // DebugName returns the debug name associated with the transaction.
 func (txn *Txn) DebugName() string {
-	return txn.txn.Name
+	return txn.Proto.Name
 }
 
 // SetSnapshotIsolation sets the transaction's isolation type to
@@ -134,7 +116,7 @@ func (txn *Txn) SetSnapshotIsolation() {
 	// TODO(pmattis): Panic if the transaction has already had
 	// operations run on it. Needs to tie into the Txn reset in case of
 	// retries.
-	txn.txn.Isolation = proto.SNAPSHOT
+	txn.Proto.Isolation = proto.SNAPSHOT
 }
 
 // InternalSetPriority sets the transaction priority. It is intended for
@@ -307,7 +289,7 @@ func (txn *Txn) CommitInBatch(b *Batch) error {
 
 // Commit sends an EndTransactionRequest with Commit=true.
 func (txn *Txn) Commit() error {
-	if txn.txn.Writing {
+	if txn.Proto.Writing {
 		return txn.sendEndTxnCall(true /* commit */)
 	}
 	return nil
@@ -316,12 +298,12 @@ func (txn *Txn) Commit() error {
 // Rollback sends an EndTransactionRequest with Commit=false.
 func (txn *Txn) Rollback() error {
 	var err error
-	if txn.txn.Writing {
+	if txn.Proto.Writing {
 		err = txn.sendEndTxnCall(false /* commit */)
 	}
 	// Explicitly set the status as ABORTED so that higher layers
 	// know that this transaction has ended.
-	txn.txn.Status = proto.ABORTED
+	txn.Proto.Status = proto.ABORTED
 	return err
 }
 
@@ -391,7 +373,7 @@ func (txn *Txn) send(calls ...proto.Call) error {
 	// If the transaction record indicates that the coordinator never wrote
 	// an intent (and the client doesn't have one lined up), then there's no
 	// need to send EndTransaction. If there is one anyways, cut it off.
-	if txn.haveEndTxn && !(txn.txn.Writing || txn.haveTxnWrite) {
+	if txn.haveEndTxn && !(txn.Proto.Writing || txn.haveTxnWrite) {
 		// There's always a call if we get here.
 		lastIndex := len(calls) - 1
 		if calls[lastIndex].Method() != proto.EndTransaction {

client/txn_test.go

@@ -123,7 +123,7 @@ func TestTxnResetTxnOnAbort(t *testing.T) {
 	txn.db.Sender.Send(context.Background(),
 		proto.Call{Args: testPutReq, Reply: &proto.PutResponse{}})
 
-	if len(txn.txn.ID) != 0 {
+	if len(txn.Proto.ID) != 0 {
 		t.Errorf("expected txn to be cleared")
 	}
 }

kv/txn_coord_sender.go

@@ -513,7 +513,7 @@ func (tc *TxnCoordSender) sendOne(ctx context.Context, call proto.Call) {
 		}
 		call.Reply.Reset()
 		if err := tmpDB.Txn(func(txn *client.Txn) error {
-			txn.SetDebugName("auto-wrap")
+			txn.SetDebugName("auto-wrap", 0)
 			b := &client.Batch{}
 			b.InternalAddCall(call)
 			return txn.CommitInBatch(b)

kv/txn_correctness_test.go

@@ -563,7 +563,7 @@ func (hv *historyVerifier) runTxn(txnIdx int, priority int32,
 	var retry int
 	txnName := fmt.Sprintf("txn%d", txnIdx)
 	err := db.Txn(func(txn *client.Txn) error {
-		txn.SetDebugName(txnName)
+		txn.SetDebugName(txnName, 0)
 		if isolation == proto.SNAPSHOT {
 			txn.SetSnapshotIsolation()
 		}

sql/server.go

@@ -115,7 +115,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 	// Open a pending transaction if needed.
 	if planMaker.session.Txn != nil {
-		planMaker.txn = client.NewTxnFromProto(*s.db, *planMaker.session.Txn)
+		txn := client.NewTxn(*s.db)
+		txn.Proto = *planMaker.session.Txn
+		planMaker.txn = txn
 	}
 
 	// Send the Request for SQL execution and set the application-level error
@@ -125,8 +127,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// Send back the session state even if there were application-level errors.
 	// Add transaction to session state.
 	if planMaker.txn != nil {
-		t := planMaker.txn.ToProto()
-		planMaker.session.Txn = &t
+		planMaker.session.Txn = &planMaker.txn.Proto
 	} else {
 		planMaker.session.Txn = nil
 	}
@@ -218,8 +219,9 @@ func (s *Server) execStmt(stmt parser.Statement, req driver.Request, planMaker *
 			// Start a transaction here and not in planMaker to prevent begin
 			// transaction from being called within an auto-transaction below.
 			planMaker.txn = client.NewTxn(*s.db)
+			planMaker.txn.SetDebugName("sql", 0)
 		}
-	} else if planMaker.txn.ToProto().Status == proto.ABORTED {
+	} else if planMaker.txn.Proto.Status == proto.ABORTED {
 		switch stmt := stmt.(type) {
 		case *parser.CommitTransaction, *parser.RollbackTransaction:
 			// Reset to allow starting a new transaction.