diff --git a/data/data.go b/data/data.go
index b6d9cbd..afb469a 100644
--- a/data/data.go
+++ b/data/data.go
@@ -3,13 +3,14 @@
 import (
 	"database/sql"
 	"fmt"
+	"os"
+	"path"
+	"runtime"
+	"sync"
+
 	"github.com/30x/apid-core"
 	"github.com/30x/apid-core/data/wrap"
 	"github.com/mattn/go-sqlite3"
-	"os"
-	"path"
-	"sync"
-	"runtime"
 )
 
 const (
@@ -119,19 +120,19 @@
 	}
 
 	log.Infof("LoadDB: %s", dataPath)
-	dataSource := fmt.Sprintf(config.GetString(configDataSourceKey), dataPath)
+	source := fmt.Sprintf(config.GetString(configDataSourceKey), dataPath)
 
 	wrappedDriverName := "dd:" + config.GetString(configDataDriverKey)
-	dataDriver := wrap.WrapDriver{&sqlite3.SQLiteDriver{}, dbTraceLog}
+	driver := wrap.NewDriver(&sqlite3.SQLiteDriver{}, dbTraceLog)
 	func() {
 		// just ignore the "registered twice" panic
 		defer func() {
 			recover()
 		}()
-		sql.Register(wrappedDriverName, &dataDriver)
+		sql.Register(wrappedDriverName, driver)
 	}()
 
-	db, err = sql.Open(wrappedDriverName, dataSource)
+	db, err = sql.Open(wrappedDriverName, source)
 	if err != nil {
 		log.Errorf("error loading db: %s", err)
 		return
@@ -184,4 +185,4 @@
 	storagePath := config.GetString("local_storage_path")
 	relativeDataPath := config.GetString(configDataPathKey)
 	return path.Join(storagePath, relativeDataPath, id, "sqlite3")
-}
\ No newline at end of file
+}
diff --git a/data/wrap/connection.go b/data/wrap/connection.go
index bd865b3..d643a88 100644
--- a/data/wrap/connection.go
+++ b/data/wrap/connection.go
@@ -1,14 +1,19 @@
 package wrap
 
 import (
+	"database/sql/driver"
+
+	"sync/atomic"
+
 	"github.com/30x/apid-core"
 	"github.com/mattn/go-sqlite3"
-	"database/sql/driver"
 )
 
 type wrapConn struct {
 	*sqlite3.SQLiteConn
-	log apid.LogService
+	log         apid.LogService
+	stmtCounter int64
+	txCounter   int64
 }
 
 func (c *wrapConn) Swap(cc *sqlite3.SQLiteConn) {
@@ -16,42 +21,46 @@
 }
 
 func (c *wrapConn) Prepare(query string) (driver.Stmt, error) {
-	c.log.Debugf("begin prepare stmt: %s", query)
+	stmtID := atomic.AddInt64(&c.stmtCounter, 1)
+	log := c.log.WithField("stmt", stmtID)
+	log.Debugf("begin prepare stmt: %s", query)
 
 	stmt, err := c.SQLiteConn.Prepare(query)
 	if err != nil {
-		c.log.Errorf("prepare stmt failed: %s", err)
+		log.Errorf("prepare stmt failed: %s", err)
 		return nil, err
 	}
 
-	c.log.Debug("end prepare stmt")
+	log.Debug("end prepare stmt")
 	s := stmt.(*sqlite3.SQLiteStmt)
-	return &wrapStmt{s, c.log}, nil
+	return &wrapStmt{s, log}, nil
 }
 
 func (c *wrapConn) Begin() (driver.Tx, error) {
-	c.log.Debug("begin trans")
+	txID := atomic.AddInt64(&c.txCounter, 1)
+	log := c.log.WithField("tx", txID)
+	log.Debug("begin trans %d", txID)
 
 	tx, err := c.SQLiteConn.Begin()
 	if err != nil {
-		c.log.Errorf("begin trans failed: %s", err)
+		log.Errorf("begin trans failed: %s", err)
 		return nil, err
 	}
 
-	c.log.Debug("end begin trans")
+	log.Debug("end begin trans")
 	t := tx.(*sqlite3.SQLiteTx)
-	return &wrapTx{t, c.log}, nil
+	return &wrapTx{t, log}, nil
 }
 
 func (c *wrapConn) Close() (err error) {
-	c.log.Debug("begin close")
+	c.log.Debug("begin close conn")
 
 	if err = c.SQLiteConn.Close(); err != nil {
-		c.log.Errorf("close failed: %s", err)
+		c.log.Errorf("close conn failed: %s", err)
 		return
 	}
 
-	c.log.Debug("end close")
+	c.log.Debug("end close conn")
 	return
 }
 
diff --git a/data/wrap/driver.go b/data/wrap/driver.go
index 62a799a..686eb13 100644
--- a/data/wrap/driver.go
+++ b/data/wrap/driver.go
@@ -3,23 +3,35 @@
 import (
 	"database/sql/driver"
 	"strings"
+
+	"sync/atomic"
+
 	"github.com/30x/apid-core"
 	"github.com/mattn/go-sqlite3"
 )
 
-type WrapDriver struct {
-	driver.Driver
-	Log apid.LogService
+func NewDriver(d driver.Driver, log apid.LogService) driver.Driver {
+	return wrapDriver{d, log, 0}
 }
 
-func (d WrapDriver) Open(dsn string) (driver.Conn, error) {
+type wrapDriver struct {
+	driver.Driver
+	log     apid.LogService
+	counter int64
+}
+
+func (d wrapDriver) Open(dsn string) (driver.Conn, error) {
+	connId := atomic.AddInt64(&d.counter, 1)
+	log := d.log.WithField("conn", connId)
+	log.Debug("begin open conn")
 
 	internalDSN := strings.TrimPrefix(dsn, "dd:")
 	internalCon, err := d.Driver.Open(internalDSN)
 	if err != nil {
+		log.Errorf("open conn failed: %v", err)
 		return nil, err
 	}
 
 	c := internalCon.(*sqlite3.SQLiteConn)
-	return &wrapConn{c, d.Log}, nil
+	return &wrapConn{c, log, 0, 0}, nil
 }