Remove logging entries using a regexp

A previous commit attempted to handler mappings produces using the glog
package by matching the column on which the sentinel was found.

However, some tools generate the mapping using a single log entry,
where the prefix appears only on the first line.

Instead of matching by column, use a regexp to identify and match
prefixes introduced by the glog package.

profile/legacy_profile.go

@@ -63,6 +63,10 @@ var (
 
 	procMapsRE  = regexp.MustCompile(`^` + cHexRange + cPerm + cSpaceHex + hexPair + spaceDigits + cSpaceString)
 	briefMapsRE = regexp.MustCompile(`^` + cHexRange + cPerm + cSpaceString + cSpaceAtOffset + cSpaceHex)
+
+	// Regular expression to parse log data, of the form:
+	// ... file:line] msg...
+	logInfoRE = regexp.MustCompile(`^[^\[\]]+:[0-9]+]\s`)
 )
 
 func isSpaceOrComment(line string) bool {
@@ -964,25 +968,11 @@ func ParseProcMaps(rd io.Reader) ([]*Mapping, error) {
 func parseProcMapsFromScanner(s *bufio.Scanner) ([]*Mapping, error) {
 	var mapping []*Mapping
 
-	// If the memory-map sentinel is at column X, assume memory mappings
-	// also start at X. This is useful to eliminate logging information.
-	offset := memoryMapSentinelOffset(s.Text())
-
 	var attrs []string
-	var r *strings.Replacer
 	const delimiter = "="
+	r := strings.NewReplacer()
 	for s.Scan() {
-		line := s.Text()
-		if len(line) > offset {
-			line = line[offset:]
-		}
-		if line = strings.TrimSpace(line); line == "" {
-			continue
-		}
-
-		if r != nil {
-			line = r.Replace(line)
-		}
+		line := r.Replace(removeLoggingInfo(s.Text()))
 		m, err := parseMappingEntry(line)
 		if err != nil {
 			if err == errUnrecognized {
@@ -1008,6 +998,16 @@ func parseProcMapsFromScanner(s *bufio.Scanner) ([]*Mapping, error) {
 	return mapping, nil
 }
 
+// removeLoggingInfo detects and removes log prefix entries generated
+// by the glog package. If no logging prefix is detected, the string
+// is returned unmodified.
+func removeLoggingInfo(line string) string {
+	if match := logInfoRE.FindStringIndex(line); match != nil {
+		return line[match[1]:]
+	}
+	return line
+}
+
 // ParseMemoryMap parses a memory map in the format of
 // /proc/self/maps, and overrides the mappings in the current profile.
 // It renumbers the samples and locations in the profile correspondingly.
@@ -1081,18 +1081,6 @@ func isMemoryMapSentinel(line string) bool {
 	return false
 }
 
-// memoryMapSentinelOffset returns the index of a known memory map
-// sentinel in the string. If the string does not contain a sentinel,
-// it returns 0.
-func memoryMapSentinelOffset(line string) int {
-	for _, s := range memoryMapSentinels {
-		if i := strings.Index(line, s); i != -1 {
-			return i
-		}
-	}
-	return 0
-}
-
 func (p *Profile) addLegacyFrameInfo() {
 	switch {
 	case isProfileType(p, heapzSampleTypes):

profile/legacy_profile_test.go

@@ -220,16 +220,47 @@ func TestParseMappingEntry(t *testing.T) {
 				BuildID: "abc123456",
 			},
 		},
+		{entry: "W1220 15:07:15.201776    8272 logger.cc:12033] --- Memory map: ---\n" +
+			"0x40000-0x80000 /path/to/binary      (@FF00)            abc123456",
+			want: &Mapping{
+				Start:   0x40000,
+				Limit:   0x80000,
+				File:    "/path/to/binary",
+				Offset:  0xFF00,
+				BuildID: "abc123456",
+			},
+		},
+		{entry: "W1220 15:07:15.201776    8272 logger.cc:12033] --- Memory map: ---\n" +
+			"W1220 15:07:15.202776    8272 logger.cc:12036]   0x40000-0x80000 /path/to/binary      (@FF00)            abc123456",
+			want: &Mapping{
+				Start:   0x40000,
+				Limit:   0x80000,
+				File:    "/path/to/binary",
+				Offset:  0xFF00,
+				BuildID: "abc123456",
+			},
+		},
 		{entry: "7f5e5435e000-7f5e5455e000 ---p 00002000 00:00 1531        myprogram",
 			want: nil,
 		},
 	} {
-		got, err := parseMappingEntry(test.entry)
+		got, err := ParseProcMaps(strings.NewReader(test.entry))
 		if err != nil {
 			t.Errorf("%s: %v", test.entry, err)
+			continue
+		}
+		if test.want == nil {
+			if got, want := len(got), 0; got != want {
+				t.Errorf("%s: got %d mappings, want %d", test.entry, got, want)
+			}
+			continue
+		}
+		if got, want := len(got), 1; got != want {
+			t.Errorf("%s: got %d mappings, want %d", test.entry, got, want)
+			continue
 		}
-		if !reflect.DeepEqual(test.want, got) {
-			t.Errorf("%s want=%v got=%v", test.entry, test.want, got)
+		if !reflect.DeepEqual(test.want, got[0]) {
+			t.Errorf("%s want=%v got=%v", test.entry, test.want, got[0])
 		}
 	}
 }