Free Google Professional Cloud DevOps Actual Exam Questions - Question 7 Discussion

A imo, Stackdriver Profiler can help identify performance bottlenecks inside the applications themselves, not just the HTTP calls. While Trace focuses on request latency, Profiler gives a CPU and memory usage perspective which can highlight inefficient code causing slowness. This can be useful when dependent apps are slow internally, not just in network timing. It’s a different angle than tracing or logging HTTP times and complements those approaches. If you have control over all apps, profiling might reveal issues you wouldn’t catch with logs or traces alone.

Probably B here. If you can instrument all services with Stackdriver Trace, you get detailed visibility into each HTTP request across services, which helps pinpoint the exact bottleneck. D is practical if you can’t touch dependent apps, but B gives a more comprehensive view and helps anticipate issues before they become big problems. Even if some services are third-party, you can often still trace the calls from your app side, which is better than just logging times locally.

Maybe D makes the most sense here since you only control your Node.js app. You can’t always add tracing or profiling to all dependent services, especially if they’re third-party or legacy. Logging HTTP request and response times directly from your app gives you practical insights without needing changes elsewhere. Plus, using Stackdriver Logging to analyze those times helps pinpoint slow dependencies effectively. This approach avoids the complexity and possible limitations of instrumenting every service involved.

B imo, tracing gives a clearer picture across services without having to modify each one. It’s better for end-to-end latency insights, while D is more of a workaround if you can’t add tracing.

D imo, it’s the only option that works if you can’t change other apps.

D imo, adding logging inside our own Node.js app is straightforward and doesn't rely on changes to other services. It's the easiest way to spot slow dependencies if we can't instrument everything externally.

Option B also makes sense since Stackdriver Trace is designed for distributed tracing and can show latencies across service boundaries, which helps spot slow dependencies. But it really depends on having the ability to instrument all dependent apps. Without that, you risk missing parts of the call chain. So if the question implies full control over those apps, B would give a better end-to-end view than just logging in our own app like D.

It’s D because if we can’t add tracing or profiling to all dependent apps, logging HTTP times in our own app is the most practical way to spot slow dependencies. Tracing (B) needs deeper access to those other apps.

B, tracing shows the full HTTP call path and latencies between services.

B/D? Does the question assume we have control over all dependent apps to instrument them? If not, logging in our app (D) might be more feasible. Otherwise, tracing (B) seems helpful for inter-service issues.