log_example_test.go

Documentation: github.com/rs/zerolog

     1  // +build !binary_log
     2  
     3  package zerolog_test
     4  
     5  import (
     6  	"errors"
     7  	"fmt"
     8  	stdlog "log"
     9  	"net"
    10  	"os"
    11  	"time"
    12  
    13  	"github.com/rs/zerolog"
    14  )
    15  
    16  func ExampleNew() {
    17  	log := zerolog.New(os.Stdout)
    18  
    19  	log.Info().Msg("hello world")
    20  	// Output: {"level":"info","message":"hello world"}
    21  }
    22  
    23  func 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  
    34  func 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  
    43  func 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  
    55  type LevelNameHook struct{}
    56  
    57  func (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  
    65  type MessageHook string
    66  
    67  func (h MessageHook) Run(e *zerolog.Event, l zerolog.Level, msg string) {
    68  	e.Str("the_message", msg)
    69  }
    70  
    71  func 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  
    82  func ExampleLogger_Print() {
    83  	log := zerolog.New(os.Stdout)
    84  
    85  	log.Print("hello world")
    86  
    87  	// Output: {"level":"debug","message":"hello world"}
    88  }
    89  
    90  func 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  
    98  func ExampleLogger_Trace() {
    99  	log := zerolog.New(os.Stdout)
   100  
   101  	log.Trace().
   102  		Str("foo", "bar").
   103  		Int("n", 123).
   104  		Msg("hello world")
   105  
   106  	// Output: {"level":"trace","foo":"bar","n":123,"message":"hello world"}
   107  }
   108  
   109  func ExampleLogger_Debug() {
   110  	log := zerolog.New(os.Stdout)
   111  
   112  	log.Debug().
   113  		Str("foo", "bar").
   114  		Int("n", 123).
   115  		Msg("hello world")
   116  
   117  	// Output: {"level":"debug","foo":"bar","n":123,"message":"hello world"}
   118  }
   119  
   120  func ExampleLogger_Info() {
   121  	log := zerolog.New(os.Stdout)
   122  
   123  	log.Info().
   124  		Str("foo", "bar").
   125  		Int("n", 123).
   126  		Msg("hello world")
   127  
   128  	// Output: {"level":"info","foo":"bar","n":123,"message":"hello world"}
   129  }
   130  
   131  func ExampleLogger_Warn() {
   132  	log := zerolog.New(os.Stdout)
   133  
   134  	log.Warn().
   135  		Str("foo", "bar").
   136  		Msg("a warning message")
   137  
   138  	// Output: {"level":"warn","foo":"bar","message":"a warning message"}
   139  }
   140  
   141  func ExampleLogger_Error() {
   142  	log := zerolog.New(os.Stdout)
   143  
   144  	log.Error().
   145  		Err(errors.New("some error")).
   146  		Msg("error doing something")
   147  
   148  	// Output: {"level":"error","error":"some error","message":"error doing something"}
   149  }
   150  
   151  func ExampleLogger_WithLevel() {
   152  	log := zerolog.New(os.Stdout)
   153  
   154  	log.WithLevel(zerolog.InfoLevel).
   155  		Msg("hello world")
   156  
   157  	// Output: {"level":"info","message":"hello world"}
   158  }
   159  
   160  func ExampleLogger_Write() {
   161  	log := zerolog.New(os.Stdout).With().
   162  		Str("foo", "bar").
   163  		Logger()
   164  
   165  	stdlog.SetFlags(0)
   166  	stdlog.SetOutput(log)
   167  
   168  	stdlog.Print("hello world")
   169  
   170  	// Output: {"foo":"bar","message":"hello world"}
   171  }
   172  
   173  func ExampleLogger_Log() {
   174  	log := zerolog.New(os.Stdout)
   175  
   176  	log.Log().
   177  		Str("foo", "bar").
   178  		Str("bar", "baz").
   179  		Msg("")
   180  
   181  	// Output: {"foo":"bar","bar":"baz"}
   182  }
   183  
   184  func ExampleEvent_Dict() {
   185  	log := zerolog.New(os.Stdout)
   186  
   187  	log.Log().
   188  		Str("foo", "bar").
   189  		Dict("dict", zerolog.Dict().
   190  			Str("bar", "baz").
   191  			Int("n", 1),
   192  		).
   193  		Msg("hello world")
   194  
   195  	// Output: {"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
   196  }
   197  
   198  type User struct {
   199  	Name    string
   200  	Age     int
   201  	Created time.Time
   202  }
   203  
   204  func (u User) MarshalZerologObject(e *zerolog.Event) {
   205  	e.Str("name", u.Name).
   206  		Int("age", u.Age).
   207  		Time("created", u.Created)
   208  }
   209  
   210  type Price struct {
   211  	val  uint64
   212  	prec int
   213  	unit string
   214  }
   215  
   216  func (p Price) MarshalZerologObject(e *zerolog.Event) {
   217  	denom := uint64(1)
   218  	for i := 0; i < p.prec; i++ {
   219  		denom *= 10
   220  	}
   221  	result := []byte(p.unit)
   222  	result = append(result, fmt.Sprintf("%d.%d", p.val/denom, p.val%denom)...)
   223  	e.Str("price", string(result))
   224  }
   225  
   226  type Users []User
   227  
   228  func (uu Users) MarshalZerologArray(a *zerolog.Array) {
   229  	for _, u := range uu {
   230  		a.Object(u)
   231  	}
   232  }
   233  
   234  func ExampleEvent_Array() {
   235  	log := zerolog.New(os.Stdout)
   236  
   237  	log.Log().
   238  		Str("foo", "bar").
   239  		Array("array", zerolog.Arr().
   240  			Str("baz").
   241  			Int(1).
   242  			Dict(zerolog.Dict().
   243  				Str("bar", "baz").
   244  				Int("n", 1),
   245  			),
   246  		).
   247  		Msg("hello world")
   248  
   249  	// Output: {"foo":"bar","array":["baz",1,{"bar":"baz","n":1}],"message":"hello world"}
   250  }
   251  
   252  func ExampleEvent_Array_object() {
   253  	log := zerolog.New(os.Stdout)
   254  
   255  	// Users implements zerolog.LogArrayMarshaler
   256  	u := Users{
   257  		User{"John", 35, time.Time{}},
   258  		User{"Bob", 55, time.Time{}},
   259  	}
   260  
   261  	log.Log().
   262  		Str("foo", "bar").
   263  		Array("users", u).
   264  		Msg("hello world")
   265  
   266  	// 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"}
   267  }
   268  
   269  func ExampleEvent_Object() {
   270  	log := zerolog.New(os.Stdout)
   271  
   272  	// User implements zerolog.LogObjectMarshaler
   273  	u := User{"John", 35, time.Time{}}
   274  
   275  	log.Log().
   276  		Str("foo", "bar").
   277  		Object("user", u).
   278  		Msg("hello world")
   279  
   280  	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
   281  }
   282  
   283  func ExampleEvent_EmbedObject() {
   284  	log := zerolog.New(os.Stdout)
   285  
   286  	price := Price{val: 6449, prec: 2, unit: "$"}
   287  
   288  	log.Log().
   289  		Str("foo", "bar").
   290  		EmbedObject(price).
   291  		Msg("hello world")
   292  
   293  	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
   294  }
   295  
   296  func ExampleEvent_Interface() {
   297  	log := zerolog.New(os.Stdout)
   298  
   299  	obj := struct {
   300  		Name string `json:"name"`
   301  	}{
   302  		Name: "john",
   303  	}
   304  
   305  	log.Log().
   306  		Str("foo", "bar").
   307  		Interface("obj", obj).
   308  		Msg("hello world")
   309  
   310  	// Output: {"foo":"bar","obj":{"name":"john"},"message":"hello world"}
   311  }
   312  
   313  func ExampleEvent_Dur() {
   314  	d := 10 * time.Second
   315  
   316  	log := zerolog.New(os.Stdout)
   317  
   318  	log.Log().
   319  		Str("foo", "bar").
   320  		Dur("dur", d).
   321  		Msg("hello world")
   322  
   323  	// Output: {"foo":"bar","dur":10000,"message":"hello world"}
   324  }
   325  
   326  func ExampleEvent_Durs() {
   327  	d := []time.Duration{
   328  		10 * time.Second,
   329  		20 * time.Second,
   330  	}
   331  
   332  	log := zerolog.New(os.Stdout)
   333  
   334  	log.Log().
   335  		Str("foo", "bar").
   336  		Durs("durs", d).
   337  		Msg("hello world")
   338  
   339  	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
   340  }
   341  
   342  func ExampleEvent_Fields_map() {
   343  	fields := map[string]interface{}{
   344  		"bar": "baz",
   345  		"n":   1,
   346  	}
   347  
   348  	log := zerolog.New(os.Stdout)
   349  
   350  	log.Log().
   351  		Str("foo", "bar").
   352  		Fields(fields).
   353  		Msg("hello world")
   354  
   355  	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
   356  }
   357  
   358  func ExampleEvent_Fields_slice() {
   359  	fields := []interface{}{
   360  		"bar", "baz",
   361  		"n", 1,
   362  	}
   363  
   364  	log := zerolog.New(os.Stdout)
   365  
   366  	log.Log().
   367  		Str("foo", "bar").
   368  		Fields(fields).
   369  		Msg("hello world")
   370  
   371  	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
   372  }
   373  
   374  func ExampleContext_Dict() {
   375  	log := zerolog.New(os.Stdout).With().
   376  		Str("foo", "bar").
   377  		Dict("dict", zerolog.Dict().
   378  			Str("bar", "baz").
   379  			Int("n", 1),
   380  		).Logger()
   381  
   382  	log.Log().Msg("hello world")
   383  
   384  	// Output: {"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
   385  }
   386  
   387  func ExampleContext_Array() {
   388  	log := zerolog.New(os.Stdout).With().
   389  		Str("foo", "bar").
   390  		Array("array", zerolog.Arr().
   391  			Str("baz").
   392  			Int(1),
   393  		).Logger()
   394  
   395  	log.Log().Msg("hello world")
   396  
   397  	// Output: {"foo":"bar","array":["baz",1],"message":"hello world"}
   398  }
   399  
   400  func ExampleContext_Array_object() {
   401  	// Users implements zerolog.LogArrayMarshaler
   402  	u := Users{
   403  		User{"John", 35, time.Time{}},
   404  		User{"Bob", 55, time.Time{}},
   405  	}
   406  
   407  	log := zerolog.New(os.Stdout).With().
   408  		Str("foo", "bar").
   409  		Array("users", u).
   410  		Logger()
   411  
   412  	log.Log().Msg("hello world")
   413  
   414  	// 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"}
   415  }
   416  
   417  func ExampleContext_Object() {
   418  	// User implements zerolog.LogObjectMarshaler
   419  	u := User{"John", 35, time.Time{}}
   420  
   421  	log := zerolog.New(os.Stdout).With().
   422  		Str("foo", "bar").
   423  		Object("user", u).
   424  		Logger()
   425  
   426  	log.Log().Msg("hello world")
   427  
   428  	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
   429  }
   430  
   431  func ExampleContext_EmbedObject() {
   432  
   433  	price := Price{val: 6449, prec: 2, unit: "$"}
   434  
   435  	log := zerolog.New(os.Stdout).With().
   436  		Str("foo", "bar").
   437  		EmbedObject(price).
   438  		Logger()
   439  
   440  	log.Log().Msg("hello world")
   441  
   442  	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
   443  }
   444  
   445  func ExampleContext_Interface() {
   446  	obj := struct {
   447  		Name string `json:"name"`
   448  	}{
   449  		Name: "john",
   450  	}
   451  
   452  	log := zerolog.New(os.Stdout).With().
   453  		Str("foo", "bar").
   454  		Interface("obj", obj).
   455  		Logger()
   456  
   457  	log.Log().Msg("hello world")
   458  
   459  	// Output: {"foo":"bar","obj":{"name":"john"},"message":"hello world"}
   460  }
   461  
   462  func ExampleContext_Dur() {
   463  	d := 10 * time.Second
   464  
   465  	log := zerolog.New(os.Stdout).With().
   466  		Str("foo", "bar").
   467  		Dur("dur", d).
   468  		Logger()
   469  
   470  	log.Log().Msg("hello world")
   471  
   472  	// Output: {"foo":"bar","dur":10000,"message":"hello world"}
   473  }
   474  
   475  func ExampleContext_Durs() {
   476  	d := []time.Duration{
   477  		10 * time.Second,
   478  		20 * time.Second,
   479  	}
   480  
   481  	log := zerolog.New(os.Stdout).With().
   482  		Str("foo", "bar").
   483  		Durs("durs", d).
   484  		Logger()
   485  
   486  	log.Log().Msg("hello world")
   487  
   488  	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
   489  }
   490  
   491  func ExampleContext_IPAddr() {
   492  	hostIP := net.IP{192, 168, 0, 100}
   493  	log := zerolog.New(os.Stdout).With().
   494  		IPAddr("HostIP", hostIP).
   495  		Logger()
   496  
   497  	log.Log().Msg("hello world")
   498  
   499  	// Output: {"HostIP":"192.168.0.100","message":"hello world"}
   500  }
   501  
   502  func ExampleContext_IPPrefix() {
   503  	route := net.IPNet{IP: net.IP{192, 168, 0, 0}, Mask: net.CIDRMask(24, 32)}
   504  	log := zerolog.New(os.Stdout).With().
   505  		IPPrefix("Route", route).
   506  		Logger()
   507  
   508  	log.Log().Msg("hello world")
   509  
   510  	// Output: {"Route":"192.168.0.0/24","message":"hello world"}
   511  }
   512  
   513  func ExampleContext_MACAddr() {
   514  	mac := net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}
   515  	log := zerolog.New(os.Stdout).With().
   516  		MACAddr("hostMAC", mac).
   517  		Logger()
   518  
   519  	log.Log().Msg("hello world")
   520  
   521  	// Output: {"hostMAC":"00:14:22:01:23:45","message":"hello world"}
   522  }
   523  
   524  func ExampleContext_Fields_map() {
   525  	fields := map[string]interface{}{
   526  		"bar": "baz",
   527  		"n":   1,
   528  	}
   529  
   530  	log := zerolog.New(os.Stdout).With().
   531  		Str("foo", "bar").
   532  		Fields(fields).
   533  		Logger()
   534  
   535  	log.Log().Msg("hello world")
   536  
   537  	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
   538  }
   539  
   540  func ExampleContext_Fields_slice() {
   541  	fields := []interface{}{
   542  		"bar", "baz",
   543  		"n", 1,
   544  	}
   545  
   546  	log := zerolog.New(os.Stdout).With().
   547  		Str("foo", "bar").
   548  		Fields(fields).
   549  		Logger()
   550  
   551  	log.Log().Msg("hello world")
   552  
   553  	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
   554  }
   555
View as plain text