libtrace/trace_impl.go at master · jfrabaute/libtrace · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package libtrace

import "os/exec"

func NewTracer(cmd *exec.Cmd) Tracer {
	return &tracerImpl{
		cmd: cmd,
		globalCallbacksOnEnter: make([]TracerCb, 0, 1),
		globalCallbacksOnExit:  make([]TracerCb, 0, 1),
		callbacksOnEnter:       make(map[string][]TracerCb),
		callbacksOnExit:        make(map[string][]TracerCb),
		globalChannelsOnEnter:  make([]chan<- *Trace, 0, 1),
		globalChannelsOnExit:   make([]chan<- *Trace, 0, 1),
		channelsOnEnter:        make(map[string][]chan<- *Trace),
		channelsOnExit:         make(map[string][]chan<- *Trace),

		maxStringSize: 32,
		maxBufferSize: 32,
	}
}

type tracerImpl struct {
	cmd *exec.Cmd

	globalCallbacksOnEnter []TracerCb
	globalCallbacksOnExit  []TracerCb
	callbacksOnEnter       map[string][]TracerCb
	callbacksOnExit        map[string][]TracerCb

	globalChannelsOnEnter []chan<- *Trace
	globalChannelsOnExit  []chan<- *Trace
	channelsOnEnter       map[string][]chan<- *Trace
	channelsOnExit        map[string][]chan<- *Trace

	maxStringSize uint64
	maxBufferSize uint64
}

func (t *tracerImpl) RegisterCb(cb TracerCb, fnNames ...string) {
	t.RegisterCbOnEnter(cb, fnNames...)
	t.RegisterCbOnExit(cb, fnNames...)
}

func (t *tracerImpl) RegisterCbOnEnter(cb TracerCb, fnNames ...string) {
	var cbs []TracerCb
	for _, name := range fnNames {
		if cbs = t.callbacksOnEnter[name]; cbs == nil {
			cbs = make([]TracerCb, 0, 1)
		}
		cbs = append(cbs, cb)
		t.callbacksOnEnter[name] = cbs
	}
}

func (t *tracerImpl) RegisterCbOnExit(cb TracerCb, fnNames ...string) {
	var cbs []TracerCb
	for _, name := range fnNames {
		if cbs = t.callbacksOnExit[name]; cbs == nil {
			cbs = make([]TracerCb, 0, 1)
		}
		cbs = append(cbs, cb)
		t.callbacksOnExit[name] = cbs
	}
}

func (t *tracerImpl) RegisterGlobalCb(cb TracerCb) {
	t.RegisterGlobalCbOnEnter(cb)
	t.RegisterGlobalCbOnExit(cb)
}

func (t *tracerImpl) RegisterGlobalCbOnEnter(cb TracerCb) {
	t.globalCallbacksOnEnter = append(t.globalCallbacksOnEnter, cb)
}

func (t *tracerImpl) RegisterGlobalCbOnExit(cb TracerCb) {
	t.globalCallbacksOnExit = append(t.globalCallbacksOnExit, cb)
}

func (t *tracerImpl) RegisterChannel(out chan<- *Trace, fnNames ...string) {
	t.RegisterChannelOnEnter(out, fnNames...)
	t.RegisterChannelOnExit(out, fnNames...)
}

func (t *tracerImpl) RegisterChannelOnEnter(out chan<- *Trace, fnNames ...string) {
	var cbs []chan<- *Trace
	for _, name := range fnNames {
		if cbs = t.channelsOnEnter[name]; cbs == nil {
			cbs = make([]chan<- *Trace, 0, 1)
		}
		cbs = append(cbs, out)
		t.channelsOnEnter[name] = cbs
	}
}

func (t *tracerImpl) RegisterChannelOnExit(out chan<- *Trace, fnNames ...string) {
	var cbs []chan<- *Trace
	for _, name := range fnNames {
		if cbs = t.channelsOnExit[name]; cbs == nil {
			cbs = make([]chan<- *Trace, 0, 1)
		}
		cbs = append(cbs, out)
		t.channelsOnExit[name] = cbs
	}
}

func (t *tracerImpl) RegisterGlobalChannel(out chan<- *Trace) {
	t.RegisterGlobalChannelOnEnter(out)
	t.RegisterGlobalChannelOnExit(out)
}

func (t *tracerImpl) RegisterGlobalChannelOnEnter(out chan<- *Trace) {
	t.globalChannelsOnEnter = append(t.globalChannelsOnEnter, out)
}

func (t *tracerImpl) RegisterGlobalChannelOnExit(out chan<- *Trace) {
	t.globalChannelsOnExit = append(t.globalChannelsOnExit, out)
}

func (t *tracerImpl) SetMaxStringSize(strSize uint64) {
	t.maxStringSize = strSize
}

func (t *tracerImpl) SetMaxBufferSize(bufferSize uint64) {
	t.maxBufferSize = bufferSize
}