doc updates, and relabel ReportMethod

in the Logrus context it's the caller, so use that internally.  Label
stays as 'method' since in the context of the log event that seems more
correct.

README.md

@@ -55,7 +55,7 @@ To ensure this behaviour even if a TTY is attached, set your formatter as follow
 
 If you wish to add the calling method as a field, instruct the logger via:
 ```
-log.SetReportMethod(true)
+log.SetReportCaller(true)
 ```
 This adds the caller as 'method' like so:
 

entry.go

@@ -46,7 +46,7 @@ type Entry struct {
 	Level Level
 
 	// Calling method, with package name
-	Method string
+	Caller string
 
 	// Message passed to Debug, Info, Warn, Error, Fatal or Panic
 	Message string
@@ -135,8 +135,8 @@ func (entry Entry) log(level Level, msg string) {
 	entry.Time = time.Now()
 	entry.Level = level
 	entry.Message = msg
-	if ReportMethod() {
+	if ReportCaller() {
-		entry.Method = getCaller()
+		entry.Caller = getCaller()
 	}
 	if err := entry.Logger.Hooks.Fire(level, &entry); err != nil {
 		entry.Logger.mu.Lock()

exported.go

@@ -27,20 +27,18 @@ func SetFormatter(formatter Formatter) {
 	std.Formatter = formatter
 }
 
-// SetReportMethod sets whether to include calling method and line as
+// SetReportCaller sets whether to include the calling method as a field
-// fields
+func SetReportCaller(include bool) {
-func SetReportMethod(include bool) {
 	std.mu.Lock()
 	defer std.mu.Unlock()
-	std.ReportMethod = include
+	std.ReportCaller = include
 }
 
-// ReportMethod sets whether to include calling method and line as
+// ReportCaller returns the 'include calling method' state
-// fields
+func ReportCaller() bool {
-func ReportMethod() bool {
 	std.mu.Lock()
 	defer std.mu.Unlock()
-	return std.ReportMethod
+	return std.ReportCaller
 }
 
 // SetLevel sets the standard logger level.

formatter.go

@@ -44,8 +44,8 @@ func prefixFieldClashes(data Fields) {
 		data["fields.level"] = l
 	}
 
-	// If ReportMethod is not set, 'method' will not conflict.
+	// If Reportmethod is not set, 'method' will not conflict.
-	if ReportMethod() {
+	if ReportCaller() {
 		if l, ok := data["method"]; ok {
 			data["fields.method"] = l
 		}

json_formatter.go

@@ -12,7 +12,7 @@ const (
 	FieldKeyMsg    = "msg"
 	FieldKeyLevel  = "level"
 	FieldKeyTime   = "time"
-	FieldKeyMethod = "method"
+	FieldKeyCaller = "method"
 )
 
 func (f FieldMap) resolve(key fieldKey) string {
@@ -34,7 +34,7 @@ type JSONFormatter struct {
 	// 		 FieldKeyTime:   "@timestamp",
 	// 		 FieldKeyLevel:  "@level",
 	// 		 FieldKeyMsg:    "@message",
-	// 		 FieldKeyMethod: "@caller",
+	// 		 FieldKeyCaller: "@caller",
 	//    },
 	// }
 	FieldMap FieldMap
@@ -62,8 +62,8 @@ func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
 	data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat)
 	data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message
 	data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()
-	if ReportMethod() {
+	if ReportCaller() {
-		data[f.FieldMap.resolve(FieldKeyMethod)] = entry.Method
+		data[f.FieldMap.resolve(FieldKeyCaller)] = entry.Caller
 	}
 	serialized, err := json.Marshal(data)
 	if err != nil {

json_formatter_test.go

@@ -170,8 +170,8 @@ func TestJSONTimeKey(t *testing.T) {
 	}
 }
 
-func TestFieldDoesNotClashWithMethod(t *testing.T) {
+func TestFieldDoesNotClashWithCaller(t *testing.T) {
-	SetReportMethod(false)
+	SetReportCaller(false)
 	formatter := &JSONFormatter{}
 
 	b, err := formatter.Format(WithField("method", "howdy pardner"))
@@ -186,12 +186,12 @@ func TestFieldDoesNotClashWithMethod(t *testing.T) {
 	}
 
 	if entry["method"] != "howdy pardner" {
-		t.Fatal("method field replaced when ReportMethod=false")
+		t.Fatal("method field replaced when ReportCaller=false")
 	}
 }
 
-func TestFieldClashWithMethod(t *testing.T) {
+func TestFieldClashWithCaller(t *testing.T) {
-	SetReportMethod(true)
+	SetReportCaller(true)
 	formatter := &JSONFormatter{}
 
 	b, err := formatter.Format(WithField("method", "howdy pardner"))
@@ -206,14 +206,14 @@ func TestFieldClashWithMethod(t *testing.T) {
 	}
 
 	if entry["fields.method"] != "howdy pardner" {
-		t.Fatalf("fields.method not set to original method field when ReportMethod=true (got '%s')",
+		t.Fatalf("fields.method not set to original method field when ReportCaller=true (got '%s')",
 			entry["fields.method"])
 	}
 
 	if entry["method"] != "" { // since we didn't actually log, it's set to the empty string
-		t.Fatalf("method not set as expected when ReportMethod=true (got '%s')",
+		t.Fatalf("method not set as expected when ReportCaller=true (got '%s')",
 			entry["method"])
 	}
 
-	SetReportMethod(false) // return to default value
+	SetReportCaller(false) // return to default value
 }

logger.go

@@ -24,7 +24,7 @@ type Logger struct {
 	Formatter Formatter
 
 	//Flag for whether to log caller info (off by default)
-	ReportMethod bool
+	ReportCaller bool
 
 	// The logging level the logger should log at. This is typically (and defaults
 	// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
@@ -75,7 +75,7 @@ func New() *Logger {
 		Formatter:    new(TextFormatter),
 		Hooks:        make(LevelHooks),
 		Level:        InfoLevel,
-		ReportMethod: false,
+		ReportCaller: false,
 	}
 }
 

logrus_test.go

@@ -56,11 +56,11 @@ func LogAndAssertText(t *testing.T, log func(*Logger), assertions func(fields ma
 	assertions(fields)
 }
 
-// TestReportMethod verifies that when ReportMethod is set, the 'method' field
+// TestReportCaller verifies that when ReportCaller is set, the 'method' field
 // is added, and when it is unset it is not set or modified
-func TestReportMethod(t *testing.T) {
+func TestReportCaller(t *testing.T) {
 	LogAndAssertJSON(t, func(log *Logger) {
-		SetReportMethod(false)
+		SetReportCaller(false)
 		log.Print("testNoCaller")
 	}, func(fields Fields) {
 		assert.Equal(t, fields["msg"], "testNoCaller")
@@ -69,7 +69,7 @@ func TestReportMethod(t *testing.T) {
 	})
 
 	LogAndAssertJSON(t, func(log *Logger) {
-		SetReportMethod(true)
+		SetReportCaller(true)
 		log.Print("testWithCaller")
 	}, func(fields Fields) {
 		assert.Equal(t, fields["msg"], "testWithCaller")
@@ -77,7 +77,7 @@ func TestReportMethod(t *testing.T) {
 		assert.Equal(t, fields["method"], "testing.tRunner")
 	})
 
-	SetReportMethod(false) // return to default value
+	SetReportCaller(false) // return to default value
 }
 
 func TestPrint(t *testing.T) {
@@ -269,7 +269,7 @@ func TestNestedLoggingReportsCorrectCaller(t *testing.T) {
 	var buffer bytes.Buffer
 	var fields Fields
 
-	SetReportMethod(true)
+	SetReportCaller(true)
 	logger := New()
 	logger.Out = &buffer
 	logger.Formatter = new(JSONFormatter)
@@ -311,7 +311,7 @@ func TestNestedLoggingReportsCorrectCaller(t *testing.T) {
 	assert.Nil(t, fields["fields.msg"], "should not have prefixed previous `msg` entry")
 	assert.Equal(t, "testing.tRunner", fields["method"])
 
-	SetReportMethod(false) // return to default value
+	SetReportCaller(false) // return to default value
 }
 
 func TestConvertLevelToString(t *testing.T) {

text_formatter.go

@@ -88,8 +88,8 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
 			f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
 		}
 		f.appendKeyValue(b, "level", entry.Level.String())
-		if ReportMethod() {
+		if ReportCaller() {
-			f.appendKeyValue(b, "method", entry.Method)
+			f.appendKeyValue(b, "method", entry.Caller)
 		}
 		if entry.Message != "" {
 			f.appendKeyValue(b, "msg", entry.Message)
@@ -119,8 +119,8 @@ func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []strin
 	levelText := strings.ToUpper(entry.Level.String())[0:4]
 
 	caller := ""
-	if ReportMethod() {
+	if ReportCaller() {
-		caller = fmt.Sprintf(" %s()", entry.Method)
+		caller = fmt.Sprintf(" %s()", entry.Caller)
 	}
 
 	if !f.FullTimestamp {