diff --git a/eth/tracers/logger/logger.go b/eth/tracers/logger/logger.go
index 8461935822..c54d294877 100644
--- a/eth/tracers/logger/logger.go
+++ b/eth/tracers/logger/logger.go
@@ -99,12 +99,22 @@ func (s *StructLog) ErrorString() string {
 	return ""
 }
 
+type wrappedLog struct {
+	parent   *wrappedLog
+	error    error
+	log      StructLog
+	children []*wrappedLog
+}
+
 // StructLogger is an EVM state logger and implements EVMLogger.
 //
 // StructLogger can capture state based on the given Log configuration and also keeps
 // a track record of modified storage which is used in reporting snapshots of the
 // contract their storage.
 type StructLogger struct {
+	current *wrappedLog
+	depth   int
+
 	cfg Config
 	env *vm.EVM
 
@@ -136,12 +146,36 @@ func (l *StructLogger) Reset() {
 // CaptureStart implements the EVMLogger interface to initialize the tracing operation.
 func (l *StructLogger) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
 	l.env = env
+	l.depth = 0
+	l.current = &wrappedLog{}
 }
 
 // CaptureState logs a new structured log message and pushes it out to the environment
 //
 // CaptureState also tracks SLOAD/SSTORE ops to track storage change.
 func (l *StructLogger) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+	for ; l.depth > depth-1; l.depth-- {
+		l.current = l.current.parent
+	}
+	if err != nil {
+		l.current.error = err
+	}
+	switch op {
+	case vm.CALL, vm.DELEGATECALL, vm.STATICCALL, vm.CALLCODE:
+		l.depth = l.depth + 1
+		wl := &wrappedLog{
+			parent: l.current,
+			error:  l.current.error,
+		}
+		l.current.children = append(l.current.children, wl)
+		l.current = wl
+	case vm.REVERT:
+		l.current.error = vm.ErrExecutionReverted
+		return
+	default:
+		return
+	}
+
 	memory := scope.Memory
 	stack := scope.Stack
 	contract := scope.Contract
@@ -198,7 +232,7 @@ func (l *StructLogger) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, s
 	}
 	// create a new snapshot of the EVM.
 	log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, rdata, storage, depth, l.env.StateDB.GetRefund(), err}
-	l.logs = append(l.logs, log)
+	l.current.log = log
 }
 
 // CaptureFault implements the EVMLogger interface to trace an execution fault
@@ -208,6 +242,17 @@ func (l *StructLogger) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, s
 
 // CaptureEnd is called after the call finishes to finalize the tracing.
 func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) {
+	for ; l.depth > 1; l.depth-- {
+		l.current = l.current.parent
+	}
+	l.current.log = StructLog{
+		Op:         vm.CALL,
+		GasCost:    gasUsed,
+		ReturnData: output,
+		Depth:      0,
+		Err:        err,
+	}
+
 	l.output = output
 	l.err = err
 	if l.cfg.Debug {
@@ -223,8 +268,19 @@ func (l *StructLogger) CaptureEnter(typ vm.OpCode, from common.Address, to commo
 
 func (l *StructLogger) CaptureExit(output []byte, gasUsed uint64, err error) {}
 
+// Depth first append for all children (stack max depth is 1024)
+func (l *wrappedLog) getLogs() []StructLog {
+	var logs []StructLog
+	l.log.Err = l.error
+	logs = append(logs, l.log)
+	for _, child := range l.children {
+		logs = append(logs, child.getLogs()...)
+	}
+	return logs
+}
+
 // StructLogs returns the captured log entries.
-func (l *StructLogger) StructLogs() []StructLog { return l.logs }
+func (l *StructLogger) StructLogs() []StructLog { return l.current.getLogs() }
 
 // Error returns the VM error captured by the trace.
 func (l *StructLogger) Error() error { return l.err }