Performance monitoring in Firebase - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Firebase Performance Monitoring?

Firebase Performance Monitoring is a service that helps you understand the performance characteristics of your app by collecting data about app startup time, network requests, and screen rendering.

beginner

How does Firebase Performance Monitoring collect data?

It automatically collects data using SDKs integrated into your app, tracking key metrics like app startup time, HTTP requests, and custom traces you define.

intermediate

What is a custom trace in Firebase Performance Monitoring?

A custom trace is a way to measure the time taken by specific parts of your app's code, allowing you to track performance of custom operations beyond automatic metrics.

beginner

Why is monitoring network requests important in Firebase Performance Monitoring?

Monitoring network requests helps identify slow or failing API calls, which can cause delays or errors in your app, affecting user experience.

intermediate

How can Firebase Performance Monitoring help improve app user experience?

By showing detailed performance data, it helps developers find and fix slow parts of the app, reduce crashes, and optimize network calls, leading to a smoother user experience.

What does Firebase Performance Monitoring automatically track?

A App startup time and network requests

B User passwords

C Database schema changes

D App store ratings

Firebase Performance Monitoring automatically tracks app startup time and network requests to help analyze app performance.

What is a custom trace used for in Firebase Performance Monitoring?

A Changing app theme colors

B Tracking user login attempts

C Sending push notifications

D Measuring specific code execution time

Custom traces let you measure how long specific parts of your app's code take to run.

Which Firebase feature helps identify slow API calls?

A Performance Monitoring network request tracking

B Crashlytics

C Authentication

D Realtime Database

Performance Monitoring tracks network requests to find slow or failing API calls.

How do you add Firebase Performance Monitoring to your app?

A By writing SQL queries

B By integrating the Firebase Performance SDK

C By configuring DNS settings

D By installing a browser extension

You add Firebase Performance Monitoring by integrating its SDK into your app code.

What benefit does Firebase Performance Monitoring provide to developers?

A Manages user payments

B Automatically writes app code

C Helps find and fix performance issues

D Creates app graphics

It helps developers find and fix performance problems to improve app quality.

Explain how Firebase Performance Monitoring helps improve app performance.

Think about what data it collects and how that helps developers.

Describe the steps to set up Firebase Performance Monitoring in a mobile app.

Focus on integration and where to see results.

Practice

1. What is the main purpose of Firebase Performance Monitoring?

easy

A. To send notifications to users

B. To track app speed and identify slow parts

C. To store user data securely

D. To manage user authentication

Solution

1. Step 1: Understand the role of performance monitoring

   Performance monitoring is used to check how fast an app runs and find parts that slow it down.

2. Step 2: Compare with other Firebase features

   Features like data storage, notifications, and authentication serve different purposes unrelated to speed tracking.

3. Final Answer:

   To track app speed and identify slow parts -> Option B

4. Quick Check:

   Performance monitoring = track speed [OK]

Hint: Performance monitoring = tracking app speed [OK]

Common Mistakes:

• Confusing performance monitoring with data storage
• Thinking it manages user authentication
• Assuming it sends notifications

2. Which of the following is the correct way to initialize Firebase Performance Monitoring in your app?

easy

A. const perf = startPerformanceMonitoring(app);

B. const perf = initializePerformance();

C. const perf = getPerformance(app);

D. const perf = firebase.performance();

Solution

1. Step 1: Recall the official Firebase Performance Monitoring initialization

   The correct method is to call getPerformance(app) to start monitoring.

2. Step 2: Check other options for correctness

   Other options use incorrect or outdated function names that do not exist in Firebase SDK.

3. Final Answer:

   const perf = getPerformance(app); -> Option C

4. Quick Check:

   Use getPerformance(app) to start monitoring [OK]

Hint: Use getPerformance(app) to start monitoring [OK]

Common Mistakes:

• Using non-existent functions like initializePerformance()
• Calling firebase.performance() which is outdated
• Confusing function names with other Firebase services

3. Consider this code snippet:

const perf = getPerformance(app);
const trace = perf.trace('myTrace');
trace.start();
// some code
trace.stop();
console.log(trace.name);

What will be printed in the console?

medium

A. Error: trace.name is not defined

B. 'trace'

C. undefined

D. 'myTrace'

Solution

1. Step 1: Understand the trace creation and naming

   The trace is created with the name 'myTrace', so its name property holds 'myTrace'.

2. Step 2: Check the console.log output

   Logging trace.name prints the string 'myTrace' to the console.

3. Final Answer:

   'myTrace' -> Option D

4. Quick Check:

   trace.name = 'myTrace' [OK]

Hint: trace.name holds the trace identifier string [OK]

Common Mistakes:

• Assuming trace.name is undefined or missing
• Confusing trace object with string 'trace'
• Expecting an error from accessing trace.name

4. You wrote this code to create a custom trace:

const perf = getPerformance(app);
const trace = perf.trace('loadTime');
trace.start;
// some loading code
trace.stop();

Why does the trace not record the duration correctly?

medium

A. Because trace.start is missing parentheses and not called as a function

B. Because trace.stop() should be called before trace.start()

C. Because getPerformance(app) must be called after trace creation

D. Because the trace name 'loadTime' is invalid

Solution

1. Step 1: Check how trace.start is used

   The code uses trace.start; without parentheses, so the function is not executed.

2. Step 2: Understand function call syntax

   To start the trace, trace.start() must be called with parentheses to run the function.

3. Final Answer:

   Because trace.start is missing parentheses and not called as a function -> Option A

4. Quick Check:

   trace.start() needs parentheses to run [OK]

Hint: Always call start() with parentheses to begin trace [OK]

Common Mistakes:

• Forgetting parentheses on start() call
• Calling stop() before start()
• Thinking trace name affects recording
• Misplacing getPerformance call

5. You want to measure the time taken by two different functions in your app using Firebase Performance Monitoring. Which approach correctly creates and uses two custom traces?

hard

A. const perf = getPerformance(app);
const traceA = perf.trace('funcA');
const traceB = perf.trace('funcB');
traceA.start();
funcA();
traceA.stop();
traceB.start();
funcB();
traceB.stop();

B. const perf = getPerformance(app);
const trace = perf.trace('funcA_funcB');
trace.start();
funcA();
funcB();
trace.stop();

C. const perf = getPerformance(app);
perf.trace('funcA').start();
funcA();
perf.trace('funcA').stop();
perf.trace('funcB').start();
funcB();
perf.trace('funcB').stop();

D. const perf = getPerformance(app);
const traceA = perf.trace('funcA');
traceA.start();
funcA();
traceA.stop();
traceA.start();
funcB();
traceA.stop();

Solution

1. Step 1: Understand how to create separate traces

   Each function should have its own trace object created with a unique name.

2. Step 2: Check the usage of start and stop for each trace

   Start and stop must be called on each trace around the respective function call.

3. Step 3: Analyze each option

   const perf = getPerformance(app); const traceA = perf.trace('funcA'); const traceB = perf.trace('funcB'); traceA.start(); funcA(); traceA.stop(); traceB.start(); funcB(); traceB.stop(); correctly creates two traces and starts/stops them separately. const perf = getPerformance(app); const trace = perf.trace('funcA_funcB'); trace.start(); funcA(); funcB(); trace.stop(); uses one trace for both functions, losing separate timing. const perf = getPerformance(app); perf.trace('funcA').start(); funcA(); perf.trace('funcA').stop(); perf.trace('funcB').start(); funcB(); perf.trace('funcB').stop(); calls start and stop on new trace objects without saving them, which is incorrect. const perf = getPerformance(app); const traceA = perf.trace('funcA'); traceA.start(); funcA(); traceA.stop(); traceA.start(); funcB(); traceA.stop(); reuses the same trace for two functions, which mixes timings.

4. Final Answer:

   const perf = getPerformance(app); const traceA = perf.trace('funcA'); const traceB = perf.trace('funcB'); traceA.start(); funcA(); traceA.stop(); traceB.start(); funcB(); traceB.stop(); -> Option A

5. Quick Check:

   Separate trace per function = const perf = getPerformance(app); const traceA = perf.trace('funcA'); const traceB = perf.trace('funcB'); traceA.start(); funcA(); traceA.stop(); traceB.start(); funcB(); traceB.stop(); [OK]

Hint: Create and use separate trace objects for each function [OK]

Common Mistakes:

• Using one trace for multiple functions
• Not saving trace objects before start/stop
• Reusing the same trace for different functions