1// +build !binary_log
2
3package zerolog_test
4
5import (
6	"errors"
7	"fmt"
8	stdlog "log"
9	"net"
10	"os"
11	"time"
12
13	"github.com/rs/zerolog"
14)
15
16func ExampleNew() {
17	log := zerolog.New(os.Stdout)
18
19	log.Info().Msg("hello world")
20	// Output: {"level":"info","message":"hello world"}
21}
22
23func ExampleLogger_With() {
24	log := zerolog.New(os.Stdout).
25		With().
26		Str("foo", "bar").
27		Logger()
28
29	log.Info().Msg("hello world")
30
31	// Output: {"level":"info","foo":"bar","message":"hello world"}
32}
33
34func ExampleLogger_Level() {
35	log := zerolog.New(os.Stdout).Level(zerolog.WarnLevel)
36
37	log.Info().Msg("filtered out message")
38	log.Error().Msg("kept message")
39
40	// Output: {"level":"error","message":"kept message"}
41}
42
43func ExampleLogger_Sample() {
44	log := zerolog.New(os.Stdout).Sample(&zerolog.BasicSampler{N: 2})
45
46	log.Info().Msg("message 1")
47	log.Info().Msg("message 2")
48	log.Info().Msg("message 3")
49	log.Info().Msg("message 4")
50
51	// Output: {"level":"info","message":"message 1"}
52	// {"level":"info","message":"message 3"}
53}
54
55type LevelNameHook struct{}
56
57func (h LevelNameHook) Run(e *zerolog.Event, l zerolog.Level, msg string) {
58	if l != zerolog.NoLevel {
59		e.Str("level_name", l.String())
60	} else {
61		e.Str("level_name", "NoLevel")
62	}
63}
64
65type MessageHook string
66
67func (h MessageHook) Run(e *zerolog.Event, l zerolog.Level, msg string) {
68	e.Str("the_message", msg)
69}
70
71func ExampleLogger_Hook() {
72	var levelNameHook LevelNameHook
73	var messageHook MessageHook = "The message"
74
75	log := zerolog.New(os.Stdout).Hook(levelNameHook).Hook(messageHook)
76
77	log.Info().Msg("hello world")
78
79	// Output: {"level":"info","level_name":"info","the_message":"hello world","message":"hello world"}
80}
81
82func ExampleLogger_Print() {
83	log := zerolog.New(os.Stdout)
84
85	log.Print("hello world")
86
87	// Output: {"level":"debug","message":"hello world"}
88}
89
90func ExampleLogger_Printf() {
91	log := zerolog.New(os.Stdout)
92
93	log.Printf("hello %s", "world")
94
95	// Output: {"level":"debug","message":"hello world"}
96}
97
98func ExampleLogger_Debug() {
99	log := zerolog.New(os.Stdout)
100
101	log.Debug().
102		Str("foo", "bar").
103		Int("n", 123).
104		Msg("hello world")
105
106	// Output: {"level":"debug","foo":"bar","n":123,"message":"hello world"}
107}
108
109func ExampleLogger_Info() {
110	log := zerolog.New(os.Stdout)
111
112	log.Info().
113		Str("foo", "bar").
114		Int("n", 123).
115		Msg("hello world")
116
117	// Output: {"level":"info","foo":"bar","n":123,"message":"hello world"}
118}
119
120func ExampleLogger_Warn() {
121	log := zerolog.New(os.Stdout)
122
123	log.Warn().
124		Str("foo", "bar").
125		Msg("a warning message")
126
127	// Output: {"level":"warn","foo":"bar","message":"a warning message"}
128}
129
130func ExampleLogger_Error() {
131	log := zerolog.New(os.Stdout)
132
133	log.Error().
134		Err(errors.New("some error")).
135		Msg("error doing something")
136
137	// Output: {"level":"error","error":"some error","message":"error doing something"}
138}
139
140func ExampleLogger_WithLevel() {
141	log := zerolog.New(os.Stdout)
142
143	log.WithLevel(zerolog.InfoLevel).
144		Msg("hello world")
145
146	// Output: {"level":"info","message":"hello world"}
147}
148
149func ExampleLogger_Write() {
150	log := zerolog.New(os.Stdout).With().
151		Str("foo", "bar").
152		Logger()
153
154	stdlog.SetFlags(0)
155	stdlog.SetOutput(log)
156
157	stdlog.Print("hello world")
158
159	// Output: {"foo":"bar","message":"hello world"}
160}
161
162func ExampleLogger_Log() {
163	log := zerolog.New(os.Stdout)
164
165	log.Log().
166		Str("foo", "bar").
167		Str("bar", "baz").
168		Msg("")
169
170	// Output: {"foo":"bar","bar":"baz"}
171}
172
173func ExampleEvent_Dict() {
174	log := zerolog.New(os.Stdout)
175
176	log.Log().
177		Str("foo", "bar").
178		Dict("dict", zerolog.Dict().
179			Str("bar", "baz").
180			Int("n", 1),
181		).
182		Msg("hello world")
183
184	// Output: {"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
185}
186
187type User struct {
188	Name    string
189	Age     int
190	Created time.Time
191}
192
193func (u User) MarshalZerologObject(e *zerolog.Event) {
194	e.Str("name", u.Name).
195		Int("age", u.Age).
196		Time("created", u.Created)
197}
198
199type Price struct {
200	val  uint64
201	prec int
202	unit string
203}
204
205func (p Price) MarshalZerologObject(e *zerolog.Event) {
206	denom := uint64(1)
207	for i := 0; i < p.prec; i++ {
208		denom *= 10
209	}
210	result := []byte(p.unit)
211	result = append(result, fmt.Sprintf("%d.%d", p.val/denom, p.val%denom)...)
212	e.Str("price", string(result))
213}
214
215type Users []User
216
217func (uu Users) MarshalZerologArray(a *zerolog.Array) {
218	for _, u := range uu {
219		a.Object(u)
220	}
221}
222
223func ExampleEvent_Array() {
224	log := zerolog.New(os.Stdout)
225
226	log.Log().
227		Str("foo", "bar").
228		Array("array", zerolog.Arr().
229			Str("baz").
230			Int(1),
231		).
232		Msg("hello world")
233
234	// Output: {"foo":"bar","array":["baz",1],"message":"hello world"}
235}
236
237func ExampleEvent_Array_object() {
238	log := zerolog.New(os.Stdout)
239
240	// Users implements zerolog.LogArrayMarshaler
241	u := Users{
242		User{"John", 35, time.Time{}},
243		User{"Bob", 55, time.Time{}},
244	}
245
246	log.Log().
247		Str("foo", "bar").
248		Array("users", u).
249		Msg("hello world")
250
251	// Output: {"foo":"bar","users":[{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},{"name":"Bob","age":55,"created":"0001-01-01T00:00:00Z"}],"message":"hello world"}
252}
253
254func ExampleEvent_Object() {
255	log := zerolog.New(os.Stdout)
256
257	// User implements zerolog.LogObjectMarshaler
258	u := User{"John", 35, time.Time{}}
259
260	log.Log().
261		Str("foo", "bar").
262		Object("user", u).
263		Msg("hello world")
264
265	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
266}
267
268func ExampleEvent_EmbedObject() {
269	log := zerolog.New(os.Stdout)
270
271	price := Price{val: 6449, prec: 2, unit: "$"}
272
273	log.Log().
274		Str("foo", "bar").
275		EmbedObject(price).
276		Msg("hello world")
277
278	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
279}
280
281func ExampleEvent_Interface() {
282	log := zerolog.New(os.Stdout)
283
284	obj := struct {
285		Name string `json:"name"`
286	}{
287		Name: "john",
288	}
289
290	log.Log().
291		Str("foo", "bar").
292		Interface("obj", obj).
293		Msg("hello world")
294
295	// Output: {"foo":"bar","obj":{"name":"john"},"message":"hello world"}
296}
297
298func ExampleEvent_Dur() {
299	d := time.Duration(10 * time.Second)
300
301	log := zerolog.New(os.Stdout)
302
303	log.Log().
304		Str("foo", "bar").
305		Dur("dur", d).
306		Msg("hello world")
307
308	// Output: {"foo":"bar","dur":10000,"message":"hello world"}
309}
310
311func ExampleEvent_Durs() {
312	d := []time.Duration{
313		time.Duration(10 * time.Second),
314		time.Duration(20 * time.Second),
315	}
316
317	log := zerolog.New(os.Stdout)
318
319	log.Log().
320		Str("foo", "bar").
321		Durs("durs", d).
322		Msg("hello world")
323
324	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
325}
326
327func ExampleContext_Dict() {
328	log := zerolog.New(os.Stdout).With().
329		Str("foo", "bar").
330		Dict("dict", zerolog.Dict().
331			Str("bar", "baz").
332			Int("n", 1),
333		).Logger()
334
335	log.Log().Msg("hello world")
336
337	// Output: {"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
338}
339
340func ExampleContext_Array() {
341	log := zerolog.New(os.Stdout).With().
342		Str("foo", "bar").
343		Array("array", zerolog.Arr().
344			Str("baz").
345			Int(1),
346		).Logger()
347
348	log.Log().Msg("hello world")
349
350	// Output: {"foo":"bar","array":["baz",1],"message":"hello world"}
351}
352
353func ExampleContext_Array_object() {
354	// Users implements zerolog.LogArrayMarshaler
355	u := Users{
356		User{"John", 35, time.Time{}},
357		User{"Bob", 55, time.Time{}},
358	}
359
360	log := zerolog.New(os.Stdout).With().
361		Str("foo", "bar").
362		Array("users", u).
363		Logger()
364
365	log.Log().Msg("hello world")
366
367	// Output: {"foo":"bar","users":[{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},{"name":"Bob","age":55,"created":"0001-01-01T00:00:00Z"}],"message":"hello world"}
368}
369
370func ExampleContext_Object() {
371	// User implements zerolog.LogObjectMarshaler
372	u := User{"John", 35, time.Time{}}
373
374	log := zerolog.New(os.Stdout).With().
375		Str("foo", "bar").
376		Object("user", u).
377		Logger()
378
379	log.Log().Msg("hello world")
380
381	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
382}
383
384func ExampleContext_EmbedObject() {
385
386	price := Price{val: 6449, prec: 2, unit: "$"}
387
388	log := zerolog.New(os.Stdout).With().
389		Str("foo", "bar").
390		EmbedObject(price).
391		Logger()
392
393	log.Log().Msg("hello world")
394
395	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
396}
397
398func ExampleContext_Interface() {
399	obj := struct {
400		Name string `json:"name"`
401	}{
402		Name: "john",
403	}
404
405	log := zerolog.New(os.Stdout).With().
406		Str("foo", "bar").
407		Interface("obj", obj).
408		Logger()
409
410	log.Log().Msg("hello world")
411
412	// Output: {"foo":"bar","obj":{"name":"john"},"message":"hello world"}
413}
414
415func ExampleContext_Dur() {
416	d := time.Duration(10 * time.Second)
417
418	log := zerolog.New(os.Stdout).With().
419		Str("foo", "bar").
420		Dur("dur", d).
421		Logger()
422
423	log.Log().Msg("hello world")
424
425	// Output: {"foo":"bar","dur":10000,"message":"hello world"}
426}
427
428func ExampleContext_Durs() {
429	d := []time.Duration{
430		time.Duration(10 * time.Second),
431		time.Duration(20 * time.Second),
432	}
433
434	log := zerolog.New(os.Stdout).With().
435		Str("foo", "bar").
436		Durs("durs", d).
437		Logger()
438
439	log.Log().Msg("hello world")
440
441	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
442}
443
444func ExampleContext_IPAddr() {
445	hostIP := net.IP{192, 168, 0, 100}
446	log := zerolog.New(os.Stdout).With().
447		IPAddr("HostIP", hostIP).
448		Logger()
449
450	log.Log().Msg("hello world")
451
452	// Output: {"HostIP":"192.168.0.100","message":"hello world"}
453}
454
455func ExampleContext_IPPrefix() {
456	route := net.IPNet{IP: net.IP{192, 168, 0, 0}, Mask: net.CIDRMask(24, 32)}
457	log := zerolog.New(os.Stdout).With().
458		IPPrefix("Route", route).
459		Logger()
460
461	log.Log().Msg("hello world")
462
463	// Output: {"Route":"192.168.0.0/24","message":"hello world"}
464}
465
466func ExampleContext_MacAddr() {
467	mac := net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}
468	log := zerolog.New(os.Stdout).With().
469		MACAddr("hostMAC", mac).
470		Logger()
471
472	log.Log().Msg("hello world")
473
474	// Output: {"hostMAC":"00:14:22:01:23:45","message":"hello world"}
475}
476