5260866425

import {Profile, ProfileGroup} from '../lib/profile'
import {FileSystemDirectoryEntry} from './file-system-entry'

import {
  importFromChromeCPUProfile,
  importFromChromeTimeline,
  isChromeTimeline,
  importFromOldV8CPUProfile,
  isChromeTimelineObject,
} from './chrome'
import {importFromStackprof} from './stackprof'
import {importFromInstrumentsDeepCopy, importFromInstrumentsTrace} from './instruments'
import {importFromBGFlameGraph} from './bg-flamegraph'
import {importFromFirefox} from './firefox'
import {importSpeedscopeProfiles} from '../lib/file-format'
import {importFromV8ProfLog} from './v8proflog'
import {importFromLinuxPerf} from './linux-tools-perf'
import {importFromHaskell} from './haskell'
import {importFromSafari} from './safari'
import {ProfileDataSource, TextProfileDataSource, MaybeCompressedDataReader} from './utils'
import {importAsPprofProfile} from './pprof'
import {decodeBase64} from '../lib/utils'
import {importFromChromeHeapProfile} from './v8heapalloc'
import {isTraceEventFormatted, importTraceEvents} from './trace-event'
import {importFromCallgrind} from './callgrind'

export async function importProfileGroupFromText(
  fileName: string,
  contents: string,
): Promise<ProfileGroup | null> {
  return await importProfileGroup(new TextProfileDataSource(fileName, contents))
}

export async function importProfileGroupFromBase64(
  fileName: string,
  b64contents: string,
): Promise<ProfileGroup | null> {
  return await importProfileGroup(
    MaybeCompressedDataReader.fromArrayBuffer(fileName, decodeBase64(b64contents).buffer),
  )
}

export async function importProfilesFromFile(file: File): Promise<ProfileGroup | null> {
  return importProfileGroup(MaybeCompressedDataReader.fromFile(file))
}

export async function importProfilesFromArrayBuffer(
  fileName: string,
  buffer: ArrayBuffer,
): Promise<ProfileGroup | null> {
  return importProfileGroup(MaybeCompressedDataReader.fromArrayBuffer(fileName, buffer))
}

async function importProfileGroup(dataSource: ProfileDataSource): Promise<ProfileGroup | null> {
  const fileName = await dataSource.name()

  const profileGroup = await _importProfileGroup(dataSource)
  if (profileGroup) {
    if (!profileGroup.name) {
      profileGroup.name = fileName
    }
    for (let profile of profileGroup.profiles) {
      if (profile && !profile.getName()) {
        profile.setName(fileName)
      }
    }
    return profileGroup
  }
  return null
}

function toGroup(profile: Profile | null): ProfileGroup | null {
  if (!profile) return null
  return {name: profile.getName(), indexToView: 0, profiles: [profile]}
}

async function _importProfileGroup(dataSource: ProfileDataSource): Promise<ProfileGroup | null> {
  const fileName = await dataSource.name()

  const buffer = await dataSource.readAsArrayBuffer()

  {
    const profile = importAsPprofProfile(buffer)
    if (profile) {
      console.log('Importing as protobuf encoded pprof file')
      return toGroup(profile)
    }
  }

  const contents = await dataSource.readAsText()

  // First pass: Check known file format names to infer the file type
  if (fileName.endsWith('.speedscope.json')) {
    console.log('Importing as speedscope json file')
    return importSpeedscopeProfiles(contents.parseAsJSON())
  } else if (/Trace-\d{8}T\d{6}/.exec(fileName)) {
    console.log('Importing as Chrome Timeline Object')
    return importFromChromeTimeline(contents.parseAsJSON().traceEvents, fileName)
  } else if (fileName.endsWith('.chrome.json') || /Profile-\d{8}T\d{6}/.exec(fileName)) {
    console.log('Importing as Chrome Timeline')
    return importFromChromeTimeline(contents.parseAsJSON(), fileName)
  } else if (fileName.endsWith('.stackprof.json')) {
    console.log('Importing as stackprof profile')
    return toGroup(importFromStackprof(contents.parseAsJSON()))
  } else if (fileName.endsWith('.instruments.txt')) {
    console.log('Importing as Instruments.app deep copy')
    return toGroup(importFromInstrumentsDeepCopy(contents))
  } else if (fileName.endsWith('.linux-perf.txt')) {
    console.log('Importing as output of linux perf script')
    return importFromLinuxPerf(contents)
  } else if (fileName.endsWith('.collapsedstack.txt')) {
    console.log('Importing as collapsed stack format')
    return toGroup(importFromBGFlameGraph(contents))
  } else if (fileName.endsWith('.v8log.json')) {
    console.log('Importing as --prof-process v8 log')
    return toGroup(importFromV8ProfLog(contents.parseAsJSON()))
  } else if (fileName.endsWith('.heapprofile')) {
    console.log('Importing as Chrome Heap Profile')
    return toGroup(importFromChromeHeapProfile(contents.parseAsJSON()))
  } else if (fileName.endsWith('-recording.json')) {
    console.log('Importing as Safari profile')
    return toGroup(importFromSafari(contents.parseAsJSON()))
  } else if (fileName.startsWith('callgrind.')) {
    console.log('Importing as Callgrind profile')
    return importFromCallgrind(contents, fileName)
  }

  // Second pass: Try to guess what file format it is based on structure
  let parsed: any
  try {
    parsed = contents.parseAsJSON()
  } catch (e) {}
  if (parsed) {
    if (parsed['$schema'] === 'https://www.speedscope.app/file-format-schema.json') {
      console.log('Importing as speedscope json file')
      return importSpeedscopeProfiles(parsed)
    } else if (parsed['systemHost'] && parsed['systemHost']['name'] == 'Firefox') {
      console.log('Importing as Firefox profile')
      return toGroup(importFromFirefox(parsed))
    } else if (isChromeTimeline(parsed)) {
      console.log('Importing as Chrome Timeline')
      return importFromChromeTimeline(parsed, fileName)
    } else if (isChromeTimelineObject(parsed)) {
      console.log('Importing as Chrome Timeline Object')
      return importFromChromeTimeline(parsed.traceEvents, fileName)
    } else if ('nodes' in parsed && 'samples' in parsed && 'timeDeltas' in parsed) {
      console.log('Importing as Chrome CPU Profile')
      return toGroup(importFromChromeCPUProfile(parsed))
    } else if (isTraceEventFormatted(parsed)) {
      console.log('Importing as Trace Event Format profile')
      return importTraceEvents(parsed)
    } else if ('head' in parsed && 'samples' in parsed && 'timestamps' in parsed) {
      console.log('Importing as Chrome CPU Profile (old format)')
      return toGroup(importFromOldV8CPUProfile(parsed))
    } else if ('mode' in parsed && 'frames' in parsed && 'raw_timestamp_deltas' in parsed) {
      console.log('Importing as stackprof profile')
      return toGroup(importFromStackprof(parsed))
    } else if ('code' in parsed && 'functions' in parsed && 'ticks' in parsed) {
      console.log('Importing as --prof-process v8 log')
      return toGroup(importFromV8ProfLog(parsed))
    } else if ('head' in parsed && 'selfSize' in parsed['head']) {
      console.log('Importing as Chrome Heap Profile')
      return toGroup(importFromChromeHeapProfile(parsed))
    } else if ('rts_arguments' in parsed && 'initial_capabilities' in parsed) {
      console.log('Importing as Haskell GHC JSON Profile')
      return importFromHaskell(parsed)
    } else if ('recording' in parsed && 'sampleStackTraces' in parsed.recording) {
      console.log('Importing as Safari profile')
      return toGroup(importFromSafari(parsed))
    }
  } else {
    // Format is not JSON

    // If the first line is "# callgrind format", it's probably in Callgrind
    // Profile Format.
    if (
      /^# callgrind format/.exec(contents.firstChunk()) ||
      (/^events:/m.exec(contents.firstChunk()) && /^fn=/m.exec(contents.firstChunk()))
    ) {
      console.log('Importing as Callgrind profile')
      return importFromCallgrind(contents, fileName)
    }

    // If the first line contains "Symbol Name", preceded by a tab, it's probably
    // a deep copy from OS X Instruments.app
    if (/^[\w \t\(\)]*\tSymbol Name/.exec(contents.firstChunk())) {
      console.log('Importing as Instruments.app deep copy')
      return toGroup(importFromInstrumentsDeepCopy(contents))
    }

    const fromLinuxPerf = importFromLinuxPerf(contents)
    if (fromLinuxPerf) {
      console.log('Importing from linux perf script output')
      return fromLinuxPerf
    }

    const fromBGFlameGraph = importFromBGFlameGraph(contents)
    if (fromBGFlameGraph) {
      console.log('Importing as collapsed stack format')
      return toGroup(fromBGFlameGraph)
    }
  }

  // Unrecognized format
  return null
}

export async function importFromFileSystemDirectoryEntry(entry: FileSystemDirectoryEntry) {
  return importFromInstrumentsTrace(entry)
}

1	import {Profile, ProfileGroup} from '../lib/profile'
2	import {FileSystemDirectoryEntry} from './file-system-entry'
3
4	import {
5	importFromChromeCPUProfile,
6	importFromChromeTimeline,
7	isChromeTimeline,
8	importFromOldV8CPUProfile,
9	isChromeTimelineObject,
10	} from './chrome'
11	import {importFromStackprof} from './stackprof'
12	import {importFromInstrumentsDeepCopy, importFromInstrumentsTrace} from './instruments'
13	import {importFromBGFlameGraph} from './bg-flamegraph'
14	import {importFromFirefox} from './firefox'
15	import {importSpeedscopeProfiles} from '../lib/file-format'
16	import {importFromV8ProfLog} from './v8proflog'
17	import {importFromLinuxPerf} from './linux-tools-perf'
18	import {importFromHaskell} from './haskell'
19	import {importFromSafari} from './safari'
20	import {ProfileDataSource, TextProfileDataSource, MaybeCompressedDataReader} from './utils'
21	import {importAsPprofProfile} from './pprof'
22	import {decodeBase64} from '../lib/utils'
23	import {importFromChromeHeapProfile} from './v8heapalloc'
24	import {isTraceEventFormatted, importTraceEvents} from './trace-event'
25	import {importFromCallgrind} from './callgrind'
26
27	export async function importProfileGroupFromText(
28	fileName: string,
29	contents: string,
30	): Promise<ProfileGroup \| null> {
31	return await importProfileGroup(new TextProfileDataSource(fileName, contents))
32	}
33
34	export async function importProfileGroupFromBase64(
35	fileName: string,
36	b64contents: string,
37	): Promise<ProfileGroup \| null> {
UNCOV 38	return await importProfileGroup(
39	MaybeCompressedDataReader.fromArrayBuffer(fileName, decodeBase64(b64contents).buffer),
40	)
41	}
42
43	export async function importProfilesFromFile(file: File): Promise<ProfileGroup \| null> {
UNCOV 44	return importProfileGroup(MaybeCompressedDataReader.fromFile(file))
45	}
46
47	export async function importProfilesFromArrayBuffer(
48	fileName: string,
49	buffer: ArrayBuffer,
50	): Promise<ProfileGroup \| null> {
51	return importProfileGroup(MaybeCompressedDataReader.fromArrayBuffer(fileName, buffer))
52	}
53
54	async function importProfileGroup(dataSource: ProfileDataSource): Promise<ProfileGroup \| null> {
55	const fileName = await dataSource.name()
56
57	const profileGroup = await _importProfileGroup(dataSource)
58	if (profileGroup) {	453✔
59	if (!profileGroup.name) {	441✔
60	profileGroup.name = fileName
61	}
62	for (let profile of profileGroup.profiles) {
63	if (profile && !profile.getName()) {	1,629✔
64	profile.setName(fileName)
65	}
66	}
67	return profileGroup
68	}
69	return null
70	}
71
72	function toGroup(profile: Profile \| null): ProfileGroup \| null {
73	if (!profile) return null	132!
74	return {name: profile.getName(), indexToView: 0, profiles: [profile]}
75	}
76
77	async function _importProfileGroup(dataSource: ProfileDataSource): Promise<ProfileGroup \| null> {
78	const fileName = await dataSource.name()
79
80	const buffer = await dataSource.readAsArrayBuffer()
81
82	{
83	const profile = importAsPprofProfile(buffer)
84	if (profile) {	459✔
85	console.log('Importing as protobuf encoded pprof file')
86	return toGroup(profile)
87	}
88	}
89
90	const contents = await dataSource.readAsText()
91
92	// First pass: Check known file format names to infer the file type
93	if (fileName.endsWith('.speedscope.json')) {	453✔
94	console.log('Importing as speedscope json file')
95	return importSpeedscopeProfiles(contents.parseAsJSON())
96	} else if (/Trace-\d{8}T\d{6}/.exec(fileName)) {	444✔
97	console.log('Importing as Chrome Timeline Object')
98	return importFromChromeTimeline(contents.parseAsJSON().traceEvents, fileName)
99	} else if (fileName.endsWith('.chrome.json') \|\| /Profile-\d{8}T\d{6}/.exec(fileName)) {	1,323!
100	console.log('Importing as Chrome Timeline')
UNCOV 101	return importFromChromeTimeline(contents.parseAsJSON(), fileName)
102	} else if (fileName.endsWith('.stackprof.json')) {	441!
103	console.log('Importing as stackprof profile')
UNCOV 104	return toGroup(importFromStackprof(contents.parseAsJSON()))
105	} else if (fileName.endsWith('.instruments.txt')) {	441!
UNCOV 106	console.log('Importing as Instruments.app deep copy')
UNCOV 107	return toGroup(importFromInstrumentsDeepCopy(contents))
108	} else if (fileName.endsWith('.linux-perf.txt')) {	441✔
109	console.log('Importing as output of linux perf script')
110	return importFromLinuxPerf(contents)
111	} else if (fileName.endsWith('.collapsedstack.txt')) {	420!
UNCOV 112	console.log('Importing as collapsed stack format')
UNCOV 113	return toGroup(importFromBGFlameGraph(contents))
114	} else if (fileName.endsWith('.v8log.json')) {	420✔
115	console.log('Importing as --prof-process v8 log')
116	return toGroup(importFromV8ProfLog(contents.parseAsJSON()))
117	} else if (fileName.endsWith('.heapprofile')) {	417✔
118	console.log('Importing as Chrome Heap Profile')
119	return toGroup(importFromChromeHeapProfile(contents.parseAsJSON()))
120	} else if (fileName.endsWith('-recording.json')) {	411✔
121	console.log('Importing as Safari profile')
122	return toGroup(importFromSafari(contents.parseAsJSON()))
123	} else if (fileName.startsWith('callgrind.')) {	408✔
124	console.log('Importing as Callgrind profile')
125	return importFromCallgrind(contents, fileName)
126	}
127
128	// Second pass: Try to guess what file format it is based on structure
129	let parsed: any
130	try {
131	parsed = contents.parseAsJSON()
132	} catch (e) {}
133	if (parsed) {	393✔
134	if (parsed['$schema'] === 'https://www.speedscope.app/file-format-schema.json') {	300✔
135	console.log('Importing as speedscope json file')
136	return importSpeedscopeProfiles(parsed)
137	} else if (parsed['systemHost'] && parsed['systemHost']['name'] == 'Firefox') {	591✔
138	console.log('Importing as Firefox profile')
139	return toGroup(importFromFirefox(parsed))
140	} else if (isChromeTimeline(parsed)) {	264✔
141	console.log('Importing as Chrome Timeline')
142	return importFromChromeTimeline(parsed, fileName)
143	} else if (isChromeTimelineObject(parsed)) {	225✔
144	console.log('Importing as Chrome Timeline Object')
145	return importFromChromeTimeline(parsed.traceEvents, fileName)
146	} else if ('nodes' in parsed && 'samples' in parsed && 'timeDeltas' in parsed) {	456✔
147	console.log('Importing as Chrome CPU Profile')
148	return toGroup(importFromChromeCPUProfile(parsed))
149	} else if (isTraceEventFormatted(parsed)) {	216✔
150	console.log('Importing as Trace Event Format profile')
151	return importTraceEvents(parsed)
152	} else if ('head' in parsed && 'samples' in parsed && 'timestamps' in parsed) {	114✔
153	console.log('Importing as Chrome CPU Profile (old format)')
154	return toGroup(importFromOldV8CPUProfile(parsed))
155	} else if ('mode' in parsed && 'frames' in parsed && 'raw_timestamp_deltas' in parsed) {	126✔
156	console.log('Importing as stackprof profile')
157	return toGroup(importFromStackprof(parsed))
158	} else if ('code' in parsed && 'functions' in parsed && 'ticks' in parsed) {	54✔
159	console.log('Importing as --prof-process v8 log')
160	return toGroup(importFromV8ProfLog(parsed))
161	} else if ('head' in parsed && 'selfSize' in parsed['head']) {	48✔
162	console.log('Importing as Chrome Heap Profile')
163	return toGroup(importFromChromeHeapProfile(parsed))
164	} else if ('rts_arguments' in parsed && 'initial_capabilities' in parsed) {	36✔
165	console.log('Importing as Haskell GHC JSON Profile')
166	return importFromHaskell(parsed)
167	} else if ('recording' in parsed && 'sampleStackTraces' in parsed.recording) {	24✔
168	console.log('Importing as Safari profile')
169	return toGroup(importFromSafari(parsed))
170	}
171	} else {
172	// Format is not JSON
173
174	// If the first line is "# callgrind format", it's probably in Callgrind
175	// Profile Format.
176	if (	93✔
177	/^# callgrind format/.exec(contents.firstChunk()) \|\|	177✔
178	(/^events:/m.exec(contents.firstChunk()) && /^fn=/m.exec(contents.firstChunk()))
179	) {
180	console.log('Importing as Callgrind profile')
181	return importFromCallgrind(contents, fileName)
182	}
183
184	// If the first line contains "Symbol Name", preceded by a tab, it's probably
185	// a deep copy from OS X Instruments.app
186	if (/^[\w \t\(\)]*\tSymbol Name/.exec(contents.firstChunk())) {	78✔
187	console.log('Importing as Instruments.app deep copy')
188	return toGroup(importFromInstrumentsDeepCopy(contents))
189	}
190
191	const fromLinuxPerf = importFromLinuxPerf(contents)
192	if (fromLinuxPerf) {	60✔
193	console.log('Importing from linux perf script output')
194	return fromLinuxPerf
195	}
196
197	const fromBGFlameGraph = importFromBGFlameGraph(contents)
198	if (fromBGFlameGraph) {	39✔
199	console.log('Importing as collapsed stack format')
200	return toGroup(fromBGFlameGraph)
201	}
202	}
203
204	// Unrecognized format
205	return null
206	}
207
208	export async function importFromFileSystemDirectoryEntry(entry: FileSystemDirectoryEntry) {
209	return importFromInstrumentsTrace(entry)
210	}

jlfwong / speedscope / 5260866425

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous