Meteor Impact 2021

Many faces of performance in Meteor ⭐️

• https://www.reddit.com/user/radekmie
• https://radekmie.github.io/blog
• https://github.com/radekmie
• Radek is consultant for generic Node apps.

• Initial HTML & bundle size (and it's parsing)
• In-app logicz
• Method & Pubs response time, database queries
• Other APIs

Meteor itself is usually not the bottleneck.

Resources

• https://forums.meteor.com/t/meteor-performance-optimizations-summary-as-of-2021/55043/5
• https://www.vazco.eu/blog/how-to-effectively-monitor-the-performance-of-meteor-projects
• https://forums.meteor.com/c/performance/28

Example app:

Talk focuses on ideas, not specific code/packages.

Bundle size

• consider various regions, data plans
• 
• dynamic imports – code still there, but loaded later, changes dynamics of performance
• smaller dep alternatives
  • preact
  • date-fns
  • lodash-es
  • crypto libs
  • validation libs (eg. phone number, mime types)
• eliminate dead code
• tree shaking
  • PR #11164

Readiness time

• Measure with Lighthouse - metrics based on UX, not tech specs
  • First Contentful Paint
  • Speed index (time needed for network)
  • Largest Contentful Paint
  • Time to Interactive – considers parsing JS
  • Total Blocking Time – accumulated all above
  • Cumulative Layout Shift – considering appearing elements shifting layout (eg. fixed headers)
• Follow Lighthouse guidelines

Method response time

• Measure with Meteor APM
• 
• Focus on trends/evolution
• Focus on impact on users, not just improving benchmarks (eg. improving the fastest/easiest to improve methods)
• this.unblock, especially useful with external services
• Reduce number of ops – database op/api call
• Consider delaying ops to batches
• Optimise the code itself, using profiler

Publication response time

• Slightly less detailed aggregation charts
• 
• Check # of simultaneous pubs
• Publish fewer documents
• Extract shared pubs
  • Meteor has multiplexor of pubs -> if multiple users subscribe to same document using same query, Meteor will deduplicate the observers and share only one observer
• Use cult-of-coders:redis-oplog
• • same as with methods

API response times

• REST API, public files (if not using CDN)
• HTTP tab of Monti APM (Meteor APM is not so good yet)
• Use non-Meteor APM
  • Apollo Studio (for GraphQL)
  • Datadog APM
  • Elastic APM
  • New Relic APM
  • Raygun APM
  • Ideally use the one used in by the rest of the company, to correlate
• Log the performance
  • Extract metrics/charts from them

CRON jobs/Daemons

• Generic APMs are not designed for these, but it's usually possible with "custom" measurements.
• TIP: Expose them via API and use generic APM. Auth properly!
• Re-consider timing and batching.
• Re-consider scope – smaller often, bigger rarely.
• Offload to "worker nodes" – external micro-services
• Sometimes a MongoDB aggregation is enough, maybe for analytical database with 1h update time. To avoid scattering.

Database throughput

• Use MongoDB Atlas - scary at first, learn to read in them.
• 
• Check your indexes – remove no longer used ones. Atlas detects it.
• Check RAM usage. Prune old, incorrect data (eg. demo, examples, seed)
• Check queries via .explain()

Takeaway

• Study perf for both Node.js apps and Web apps – Meteor is both.
• https://radekmie.github.io/blog/on-software-performance/

Q&A

• Don't use unblock blindly. Use APM to check wait time (time to start executing).
• MontiAPM at the moment has more features than Meteor APM.
  • has HTTP monitoring - useful for REST, but not GraphQL (due to single endpoint)

Meteorman a DDP Client with GUI

• Hardcode values – You have to deactivate middlewares for testing as well.
• DDP Tools – Install third-party programs
• Meteor Shell

• Call methods
• Subscribe to publications and see updates in real time
• Document your endpoints with Markdown

• Cloud service - saving collections
• Shared Workspaces with team
• Load testing

New React Hooks for Meteor

• useMeteorState,
• useSubscribe,
• useFind,
• useUserId
• useUser

useFind and useSubscribe

useFind – single cursor from factory method
Plays nice with React logic.


why is isLoading method? To setup reactivity only when needed loading indicator.


Use cases: Chats, big tables.

just simple convenience wrappers

requires globally unique id, unlike useState

Q&A

Option to opt-out

findOne - use useTracker(), internally just .fetch()[0], so no special hook necessary. Don't use useFind as it creates cursor.

Diff between useSubscribe and subscribing in useTracker

React Suspense and Meteor dynamic imports

zrender will be bundled.

import will return promise.

React.lazy currently only support default export.

Why should I use MeteorJS in 2021?

https://github.com/meteor/examples

Meteor Accounts 2.0 and beyond

override email settings completely


https://github.com/meteor/meteor/discussions/11653
https://github.com/meteor/meteor/discussions/11514

Back to the roots

Meteor Community Packages in 2021

Resilient e-mail sending and other APIs integrations made easy in Meteor with Superface.ai

Superface is not acting as a Proxy, traffic goes directly to the service.

How to improve security of your Meteor app

All examples from previous real tests.

Client side auth

Server side auth

^ not owner of this file

^ Upload policy & signature
^ Upload directly to cloud storage

DoS attacks

Vulnerable packages

^ or npm-audit

Security headers

https://content-security-policy.com/

Meteor development lifecycle: Quality at scale ⭐️

https://www.targetprocess.com/

SonarQube

Q&A

• Jenkins listening to GitHub
• Automated merging and Slack notifications about conflicts