Performance tuning your Grails apps

whoami > Colin Harrington

• Grails team at OCI
• @ColinHarrington
• harringtonc@objectcomputing.com

If a tree falls in a forest ...

does it make a sound?

and no one is around to hear it,

https://en.wikipedia.org/wiki/If_a_tree_falls_in_a_forest

Metaphysics & Quantum Mechanics

• George Berkeley asked the question
   
• Albert Einstein & Neils Bohr
  • Bohr: "The moon does not exist if nobody is looking at it."
  • How do you prove it?  Prove me wrong

If your user hits a perf issue ...

does it matter to you?

and nobody reports it,

Measure

&

Monitor

Measure first philosophy

• Ask questions later
• Data > no data

User

This app is slow.

    Perception burn!

May or may not report the issue (probably not)

Measurement

User X loaded the results page in 1870ms today at 4:30pm

475 records were pulled from the DB

if (user.cares()) {
   if(user.canLocateSupport() && user.hasTime()) {
      reportSlowness()
   } 
​}

Perceived Performance

How your users feel is the reality that you are working with

Design & Code for your user

How One Second Could Cost Amazon $1.6 Billion In Sales

Front End

Web
Mobile
API

Client Heavy

Webapp Performance basics:

• Originating HTTP request
• Web Page (HTML)
• Assets, js, css, images, etc.
• Javscript app loading times
• XHR (ajax) requests
• SSE, websockets etc.

Bundling & Minification

Asset Pipeline Plugin

• Asset Bundling
• Extensible Modules (Supports LESS,Handlebars,Coffeescript, Ember-Handlebars, SASS) via other modules.
• Cache Digest Names (Creates cache digested names and stores aliases in a manifest.properties)
• Js Minification
• Js SourceMap Generation
• Css Minification / Relative Path assertion
• File Encoding Support
• GZIP File Generation
• Last-Modified Header

http://plugins.grails.org/plugin/grails/asset-pipeline

Separate Client & Server

Gradle Multi-module build

• Standalone Client
  • javascript project
  • grunt, gulp, npm tooling, dependencies, bundling etc.
• Server Backend
  • APIs
  • Rich data sources
  • Security measures
  • Testable & flexible

Content Delivery Network

• Distributed & Built to be 'close' to clients
• Caching mechanisms
• Static assets
• Maybe root html documents?
• layered / uptime / DDOS protection

Preloading Data?

• HTTP request
• HTML Response
• Browser
  • Parse HTML Document
  • Load referenced resources
  • Paint the page
  • Load Javascript app
  • Load Js dependencies
  • Initialize the app
  • API calls to fetch data. 

Front-end analytics 

• Analytics platforms
• Google Analytics
• Pingdom
• New Relic
• many, many others

Error handling

• Javascript testing!
  • Unit testing style
  • Browser testing
• Error tolerant UX 
• Visually Responsive vs blocking

Log client side Javascript errors!

• Use a lib for your framework?
• Roll your own?
• Use a 3rd party
  • Track.js
  • Sentry.io
  • Rollbar
  • Raygun
• Web analytics platforms

Latency : Time scale

Cost

• Code Performance
• Reading from Drive
  • SSD
  • Rotational
• Network latency
  • Same rack
  • Same building
  • Across the internet

Logging

Logs or it didn't happen

Quantify results

Human memory is 'lossy'

Removal of opinion

What happened surrounding

Grails uses logback

https://logback.qos.ch

•  grails-app/conf/logback.groovy
                  or...

•  grails-app/conf/logback.xml

(can also be configured externally)

Heisenberg effect

• Observing influences performance
   
• log.info("Something happened") 
• log.info("Something happened ${expensiveEvaluation()}")

https://en.wikipedia.org/wiki/Observer_effect_(physics)

Async Appenders

• Appenders blocking by default
• AsyncAppender delegates
  • Any appender can be wrapped 
• Durability vs performance
• Appenders
  • File
  • DB
  • SMTP
  • Syslog
  • ...

Log Aggregation

Log Aggregation

• Centralized
• Debugging purposes
• Analyzing
• Usage/trends
• spot & diagnose errors quickly
• Handle Many types of logs
  • System Logs
  • Application Logs
  • Load balancer logs
  • Network device logs
  • front-end error logs

Centralized

One place to rule them all!

Metrics

Visual representation

Proxy/Load Balancer timing Logs are a great place to start

monitor traffic, analyze outliars

1 picture == 1000 words

Add context to log statements

• Which Server
• Which thread
• CorrelationIDs
• User/client identifier

Mapped Diagnostic Context (MDC)

• https://logback.qos.ch/manual/mdc.html
   
• User/client identifier
   
• Early in the chain: Filter or Interceptor:

• MDC.put("user", user.name)

• Easy to search and filter

• CorrelationID from the entry point

  • (also works if included in reactive flows)
     

Starting Point

• Access Logs
  • Load balancer
  • Nginx
  • Tomcat access valve

Access logs

• Request timing (duration, when)
• HTTP status
• Size of the response
• Remote IP address
• Thread that processed the request 
• Session ID (tomcat)
• Custom headers 

Look at min/max/average response times

Historical Performance

Did the performance change over time? 

Growing? at what rate?

Interceptors

• Can be used as a simple Performance monitoring tool

class MyInterceptor {

  int order = HIGHEST_PRECEDENCE

  boolean before() { true }

  boolean after() { true }

  void afterView() {
    // no-op
  }

}

Interceptors

• Before the controller action
   
• after the controller action
   
• after the view layer is done

class MyInterceptor {

  int order = HIGHEST_PRECEDENCE

  boolean before() { true }

  boolean after() { true }

  void afterView() {
    // no-op
  }

}

Profiling Tools

• New Relic
• Datadog
• Solar Winds
• YourKit Java Profiler (works great!)
• JProfiler

YourKit Java Profiler 

JProfiler

Databases

SQL? 

• Connection Pooling usage and settings
• SQL Logging
• Shim (wraps the client driver)
• Enable Hibernate SQL logging
• Query Logging on the actual server

* warning this can be chatty!

Enable SQL logging

logger("org.hibernate.SQL", DEBUG, ["STDOUT"], false)
logger("org.hibernate.type.descriptor.sql.BasicBinder", TRACE, ["STDOUT"], false)

environments:
  local:
    dataSource:
        logSql: true
        formatSql: true

grails-app/conf/logback.groovy

Application configuration

grails-app/conf/application.yml

Profiling in other data sources

• Mongo Profiling Level 
• Redis monitoring or Slow log
• MySQL Slow Log
• Postgres logging slow queries

Slow Query

One expensive query

Usually a Complex query

1 * (Query Time + network overhead)

Many Queries

Many smaller less expensive queries

Overhead becomes important

n * (Query Time + network overhead)

GORM & Hibernate

ORMs are tough

Hibernate Session

- https://www.slideshare.net/JonasWitt1/understanding-database-transactions-and-hibernate-sessions-in-grails

Transactions

- https://www.slideshare.net/JonasWitt1/understanding-database-transactions-and-hibernate-sessions-in-grails

Hibernate Second Level Cache

• premature optimization?
• Optimize frequently used objects

Hibernate Query Cache

hasMany
Considered
Harmful

(@See Burt's talk!)

Author Example

class Author {

    String name

    static hasMany = [books: Book]
}

RxGORM

http://gorm.grails.org/

new Book(title:"The Stand")
        .save()
        .subscribe { Book it ->
    println "Title = ${it.title}"
}

Book.get(id)
    .subscribe { Book it ->
    println "Title = ${it.title}"
}

Breaking

out of

procedural Jail

Asnyc

Promises

import static grails.async.Promises.*

def p1 = task { 2 * 2 }
def p2 = task { 4 * 4 }
def p3 = task { 8 * 8 }
assert [4,16,64] == waitAll(p1, p2, p3)

import static java.util.concurrent.TimeUnit.*
import static grails.async.Promises.*

Promise p = task {
        // Long running task
}
p.onError { Throwable err ->
        println "An error occured ${err.message}"
}
p.onComplete { result ->
    println "Promise returned $result"
}
// block until result is called
def result = p.get()
// block for the specified time
def result = p.get(1,MINUTES)

class BookService {
    List<Book> findBooks(String title) {
      // implementation
    }
}

import grails.async.*

class AsyncBookService {
   @DelegateAsync BookService bookService
}

3rd Party API calls

• Network overhead 100ms?
• Orders of magnitude slower than code
• Beware of mixing with Long running Transactions

JVM Performance

Garbage Collection

• What type of GC?
• GC logs
• JVM monitoring tools

Visual VM

View layer

Grails Views

• http://views.grails.org/
• Statically Compiled Json Views!

@CompileStatic

Connect with Us

grails.org
groovy-community.grails.org
grailsblog.objectcomputing.com
objectcomputing.com/grails
@grailsframework
@objectcomputing

Thank you for attending!

Please visit our table for giveaways
and to meet the team!

ociweb.com/grails
info@ociweb.com