← Back to branch summary

~golang-logging/golang-logging/trunk

« back to all changes in this revision

Viewing changes to format.go

  • Committer: Örjan Persson
  • Date: 2016-02-06 10:54:33 UTC
  • mfrom: (56.1.1)
  • Revision ID: git-v1:f62e8e0cffc0625b81053da1ace8b62ea700f353
Merge pull request #85 from nplanel/format-callpath

[feature] Introduce new %{callpath} format keyword

Show diffs side-by-side

added added

removed removed

Lines of Context:
format.go
39
39
        fmtVerbShortpkg
40
40
        fmtVerbLongfunc
41
41
        fmtVerbShortfunc
 
42
        fmtVerbCallpath
42
43
        fmtVerbLevelColor
43
44
 
44
45
        // Keep last, there are no match for these below.
60
61
        "shortpkg",
61
62
        "longfunc",
62
63
        "shortfunc",
 
64
        "callpath",
63
65
        "color",
64
66
}
65
67
 
79
81
        "s",
80
82
        "s",
81
83
        "s",
 
84
        "s",
82
85
        "",
83
86
}
84
87
 
159
162
//     %{message}   Message (string)
160
163
//     %{longfile}  Full file name and line number: /a/b/c/d.go:23
161
164
//     %{shortfile} Final file name element and line number: d.go:23
 
165
//     %{callpath}  Callpath like main.a.b.c...c  "..." meaning recursive call
162
166
//     %{color}     ANSI color based on log level
163
167
//
164
168
// For normal types, the output can be customized by using the 'verbs' defined
187
191
//     %{shortpkg}  Base package path, eg. go-logging
188
192
//     %{longfunc}  Full function name, eg. littleEndian.PutUint32
189
193
//     %{shortfunc} Base function name, eg. PutUint32
 
194
//     %{callpath}  Call function path, eg. main.a.b.c
190
195
func NewStringFormatter(format string) (Formatter, error) {
191
196
        var fmter = &stringFormatter{}
192
197
 
308
313
                                                v = formatFuncName(part.verb, f.Name())
309
314
                                        }
310
315
                                }
 
316
                        case fmtVerbCallpath:
 
317
                                v = formatCallpath(calldepth + 1)
311
318
                        default:
312
319
                                panic("unhandled format part")
313
320
                        }
343
350
        panic("unexpected func formatter")
344
351
}
345
352
 
 
353
func formatCallpath(calldepth int) string {
 
354
        v := ""
 
355
        callers := make([]uintptr, 64)
 
356
        n := runtime.Callers(calldepth+2, callers)
 
357
        oldPc := callers[n-1]
 
358
 
 
359
        recursiveCall := false
 
360
        for i := n - 3; i >= 0; i-- {
 
361
                pc := callers[i]
 
362
                if oldPc == pc {
 
363
                        recursiveCall = true
 
364
                        continue
 
365
                }
 
366
                oldPc = pc
 
367
                if recursiveCall {
 
368
                        recursiveCall = false
 
369
                        v += ".."
 
370
                }
 
371
                if i < n-3 {
 
372
                        v += "."
 
373
                }
 
374
                if f := runtime.FuncForPC(pc); f != nil {
 
375
                        v += formatFuncName(fmtVerbShortfunc, f.Name())
 
376
                }
 
377
        }
 
378
        return v
 
379
}
 
380
 
346
381
// backendFormatter combines a backend with a specific formatter making it
347
382
// possible to have different log formats for different backends.
348
383
type backendFormatter struct {