Tips on how to improve the performance of your custom modules for high volumes deployment. Olivier Dony, OpenERP

Olivier Dony
T @odony
Performance
with high
volumes

OpenERP can handle large
volumes of transactions and
large volumes of data
out of the box!

For example, each OpenERP
Online Server hosts 1000+
databases without
breaking a sweat!

Many on-site customers have
single server deployments
with millions of rows:
partners, emails, attachments,
journal items, stock moves,
workflow items, …

What if performance is an issue?
Get the right facts.
Use the right tools.

t @odony
Agenda
● Architecture / Deployment / Sizing
● Measuring & Analyzing
● Common Problems
● Anti-patterns

PostgreSQL is the real
workhorse behind OpenERP,
and it scales very well!

t @odony
OpenERP Cron Worker
Deployment Architecture: single server, multi-process
Rule of thumb:
--workers=$((1+${CORES}*2))
OpenERP HTTP Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
PostgreSQL
Requests

t @odony
OpenERP Cron Worker
Deployment Architecture: multi-server, multi-process
OpenERP HTTP Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
PostgreSQL
Requests
Server 3
Load
Balancer
OpenERP Cron Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
OpenERP HTTP Worker
Server 2
Server 1

t @odony
Hardware Sizing
● Typical modern server machine
● 4/8/12 2+GHz cores
● 8-64 GB RAM
● Fast SATA/SAS/SSD disks
● Up to 100-200 active users (multi-process)
● Up to dozens of HTTP requests per second
● Up to 1000 “light” users (average SaaS user)
● For official OpenERP 7.0 deployments with no
customizations, and typical usage!

For anything else, always
perform proper load testing
before going live in production!
Then size accordingly...

t @odony
PostgreSQL Deployment tips
● Avoid deploying PostgreSQL on a VM
● If you must do it, fine-tune the VM for I/O!
● And always check out the basic PostgreSQL
performance tuning, it's conservative by
default
http://wiki.postgresql.org/wiki/Tuning_Your_PostgreSQL_Server

t @odony
Monitor application response times
●
You can't manage/improve what you can't
measure
●
Setup an automated monitoring of performance
and response time... even if you have no
performance problem!
●
Suggested tool: munin
●
Run OpenERP with –log-level=debug_rpc in prod!
2013-07-03 00:12:29,846 9663 DEBUG test openerp.netsvc.rpc.request:
object.execute_kw time:0.031s mem: 763716k -> 763716k (diff: 0k)('test', 1,
'*', 'sale.order', 'read', (...), {...})

t @odony
#!/bin/sh
#%# family=manual
#%# capabilities=autoconf suggest
case $1 in
autoconf)
exit 0
;;
suggest)
exit 0
;;
config)
echo graph_category openerp
echo graph_title openerp rpc request count
echo graph_vlabel num requests/minute in last 5 minutes
echo requests.label num requests
exit 0
;;
esac
# watch out for the time zone of the logs => using date -u for UTC timestamps
result=$(tail -60000 /var/log/openerp.log | grep "object.execute_kw time" | awk "BEGIN{count=0} ($1 " "
$2) >= "`date +'%F %H:%M:%S' -ud '5 min ago'`" { count+=1; } END{print count/5}")
echo "requests.value ${result}"
exit 0
Munin plugin: OpenERP requests/minute

t @odony
#!/bin/sh
#%# family=manual
case $1 in
config)
echo graph_title openerp rpc requests min/average response time
echo graph_vlabel seconds
echo graph_args --units-exponent -3
echo min.label min
echo min.warning 1
echo min.critical 5
echo avg.label average
echo avg.warning 1
echo avg.critical 5
exit 0
;;
esac
# watch out for the time zone of the logs => using date -u for UTC timestamps
result=$(tail -60000 /var/log/openerp.log | grep "object.execute_kw time" | awk "BEGIN{sum=0;count=0} (
$1 " " $2) >= "`date +'%F %H:%M:%S' -ud '5 min ago'`" {split($8,t,":");time=0+t[2];if (min=="") { min=time};
sum += time; count+=1; min=(time>min)?min:time } END{print min, sum/count}")
echo -n "min.value "
echo ${result} | cut -d" " -f1
echo -n "avg.value "
echo ${result} | cut -d" " -f2
exit 0
Munin plugin: OpenERP min/avg response time

t @odony
#!/bin/sh
#%# family=manual
case $1 in
config)
echo graph_title openerp rpc requests max response time
echo graph_vlabel seconds
echo graph_args --units-exponent -3
echo max.label max
echo max.warning 1
echo max.critical 5
exit 0
;;..
esac
# watch out for the time zone of the logs => using date -u for UTC timestamps....
result=$(tail -60000 /var/log/openerp.log | grep "object.execute_kw time" | awk "BEGIN{sum=0;count=0} (
$1 " " $2) >= "`date +'%F %H:%M:%S' -ud '85 min ago'`" {split($8,t,":");time=0+t[2]; sum += time; count+=1;
max=(time<max)?max:time } END{print max}")
echo "max.value ${result}"
exit 0
Munin plugin: OpenERP max response time

t @odony
Monitor PostgreSQL
● postgresql.conf
● log_min_duration_statement = 50
● Set to 50 or 100 in production
● Set to 0 to log all queries and execution times for a while
● Instagram gist to capture sample + analyze
● Analyze with pgBadger or pgFouine
●
lc_messages = 'C'

t @odony
PostgreSQL Analysis
● Important PG statistic tables
● pg_stat_activity: near real-time view of transactions
● pg_locks: real-time view of existing locks
● pg_stat_user_tables: generic usage stats for all tables
● pg_statio_user_tables: generic I/O stats for all tables

t @odony
PostgreSQL Analysis: longest tables
# SELECT schemaname || '.' || relname as table,n_live_tup as num_rows
FROM pg_stat_user_tables
ORDER BY n_live_tup DESC limit 10;
┌──────────────────────────────────────────┬──────────┐
│ table │ num_rows │
├──────────────────────────────────────────┼──────────┤
│ public.stock_move │ 179544 │
│ public.ir_translation │ 134039 │
│ public.wkf_workitem │ 97195 │
│ public.wkf_instance │ 96973 │
│ public.procurement_order │ 83077 │
│ public.ir_property │ 69011 │
│ public.ir_model_data │ 59532 │
│ public.stock_move_history_ids │ 58942 │
│ public.mrp_production_move_ids │ 49714 │
│ public.mrp_bom │ 46258 │
└──────────────────────────────────────────┴──────────┘

t @odony
PostgreSQL Analysis: biggest tables
# SELECT nspname || '.' || relname AS "table",
pg_size_pretty(pg_total_relation_size(C.oid)) AS "total_size"
FROM pg_class C
LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
WHERE nspname NOT IN ('pg_catalog', 'information_schema')
AND C.relkind <> 'i'
AND nspname !~ '^pg_toast'
ORDER BY pg_total_relation_size(C.oid) DESC
LIMIT 10;
┌──────────────────────────────────────────┬────────────┐
│ table │ total_size │
├──────────────────────────────────────────┼────────────┤
│ public.stock_move │ 525 MB │
│ public.wkf_workitem │ 111 MB │
│ public.procurement_order │ 80 MB │
│ public.stock_location │ 63 MB │
│ public.ir_translation │ 42 MB │
│ public.wkf_instance │ 37 MB │
│ public.ir_model_data │ 36 MB │
│ public.ir_property │ 26 MB │
│ public.ir_attachment │ 14 MB │
│ public.mrp_bom │ 13 MB │
└──────────────────────────────────────────┴────────────┘

t @odony
PostgreSQL Analysis: biggest tables
●
Consider using the file storage for the
ir.attachment table
●
Avoid storing files in the database
●
Greatly reduces the time needed for DB backups
and backup
●
Very easy to rsync backups of DB dumps +
filestore
●
For 7.0 this setting is explained in this FAQ

t @odony
PostgreSQL Analysis: most read tables
# SELECT schemaname || '.' || relname as table, heap_blks_read as disk_reads,
heap_blks_hit as cache_reads,
heap_blks_read + heap_blks_hit as total_reads
from pg_statio_user_tables
order by heap_blks_read + heap_blks_hit desc limit 15;
┌───────────────────────────────┬────────────┬─────────────┬─────────────┐
│ table │ disk_reads │ cache_reads │ total_reads │
├───────────────────────────────┼────────────┼─────────────┼─────────────┤
│ public.stock_location │ 53796 │ 60926676388 │ 60926730184 │
│ public.stock_move │ 208763 │ 9880525282 │ 9880734045 │
│ public.stock_picking │ 15772 │ 4659569791 │ 4659585563 │
│ public.procurement_order │ 156139 │ 1430660775 │ 1430816914 │
│ public.stock_tracking │ 2621 │ 525023173 │ 525025794 │
│ public.product_product │ 11178 │ 225774346 │ 225785524 │
│ public.mrp_bom │ 27198 │ 225329643 │ 225356841 │
│ public.ir_model_fields │ 1632 │ 203361139 │ 203362771 │
│ public.stock_production_lot │ 5918 │ 127915614 │ 127921532 │
│ public.res_users │ 416 │ 115506586 │ 115507002 │
│ public.ir_model_access │ 6382 │ 104686364 │ 104692746 │
│ public.mrp_production │ 20829 │ 101523983 │ 101544812 │
│ public.product_template │ 4566 │ 76074699 │ 76079265 │
│ public.product_uom │ 18 │ 70521126 │ 70521144 │
│ public.wkf_workitem │ 129166 │ 67782919 │ 67912085 │
└───────────────────────────────┴────────────┴─────────────┴─────────────┘

t @odony
PostgreSQL Analysis: most updated/inserted/...
# SELECT schemaname || '.' || relname as table,
seq_scan,idx_scan,idx_tup_fetch+seq_tup_read lines_read_total, n_tup_ins as
num_insert,n_tup_upd as num_update,n_tup_del as num_delete
from pg_stat_user_tables order by n_tup_upd desc limit 10;
┌────────────────────────────────────┬──────────┬────────────┬──────────────────┬────────────┬────────────┬────────────┐
│ table │ seq_scan │ idx_scan │ lines_read_total │ num_insert │ num_update │ num_delete │
├────────────────────────────────────┼──────────┼────────────┼──────────────────┼────────────┼────────────┼────────────┤
│ public.stock_move │ 1188095 │ 1104711719 │ 132030135782 │ 208507 │ 9556574 │ 67298 │
│ public.procurement_order │ 226774 │ 22134417 │ 11794090805 │ 92064 │ 6882666 │ 27543 │
│ public.wkf_workitem │ 373 │ 17340039 │ 29910699 │ 1958392 │ 3280141 │ 1883794 │
│ public.stock_location │ 41402098 │ 166316501 │ 516216409246 │ 97 │ 2215107 │ 205 │
│ public.stock_picking │ 297984 │ 71732467 │ 5671488265 │ 9008 │ 1000966 │ 1954 │
│ public.stock_production_lot │ 190934 │ 28038527 │ 1124560295 │ 4318 │ 722053 │ 0 │
│ public.mrp_production │ 270568 │ 13550371 │ 476534514 │ 3816 │ 495776 │ 1883 │
│ public.sale_order_line │ 30161 │ 4757426 │ 60019207 │ 2077 │ 479752 │ 320 │
│ public.stock_tracking │ 656404 │ 97874788 │ 5054452666 │ 5914 │ 404469 │ 0 │
│ public.ir_cron │ 246636 │ 818 │ 2467441 │ 0 │ 169904 │ 0 │
└────────────────────────────────────┴──────────┴────────────┴──────────────────┴────────────┴────────────┴────────────┘

t @odony
Useful VIEW to watch locked queries
-- For PostgreSQL 9.1
CREATE VIEW monitor_blocked_queries AS
SELECT
pg_class.relname,
waiter.pid as blocked_pid,
substr(wait_act.current_query,1,30) as blocked_statement,
age(now(),wait_act.query_start) as blocked_duration,
holder.pid as blocking_pid,
substr(hold_act.current_query,1,30) as blocking_statement,
age(now(),hold_act.query_start) as blocking_duration,
waiter.transactionid as xid,
waiter.mode as wmode,
waiter.virtualtransaction as wvxid,
holder.mode as hmode,
holder.virtualtransaction as hvxid
FROM pg_locks holder join pg_locks waiter on (
holder.locktype = waiter.locktype and (
holder.database, holder.relation,
holder.page, holder.tuple,
holder.virtualxid,
holder.transactionid, holder.classid,
holder.objid, holder.objsubid
) IS NOT DISTINCT from (
waiter.database, waiter.relation,
waiter.page, waiter.tuple,
waiter.virtualxid,
waiter.transactionid, waiter.classid,
waiter.objid, waiter.objsubid
))
JOIN pg_stat_activity hold_act ON (holder.pid=hold_act.procpid)
JOIN pg_stat_activity wait_act ON (waiter.pid=wait_act.procpid)
LEFT JOIN pg_class ON (holder.relation = pg_class.oid)
WHERE
wait_act.datname = 'eurogerm' AND
holder.granted AND NOT waiter.granted
ORDER BY blocked_duration DESC;

t @odony
Useful VIEW to watch locked queries
# SELECT * FROM blocked_queries;
relname | blocked_pid | blocked_statement | blocked_duration | blocking_pid | blocking_statement
---------+-------------+--------------------------------+------------------+--------------+-------------------------
| 16504 | update "stock_tracking" set "s | 00:00:57.588357 | 16338 | <IDLE> in transaction
| 16501 | update "stock_tracking" set "f | 00:00:55.144373 | 16504 | update "stock_tracking"
(2 lignes)
... | blocking_statement | blocking_duration | xid | wmode | hmode |
... +--------------------------------+-------------------+----------+-----------+---------------|
... | <IDLE> in transaction | -00:00:00.004754 | 12630740 | ShareLock | ExclusiveLock |
... | update "stock_tracking" set "s | 00:00:57.588357 | 12630722 | ShareLock | ExclusiveLock |

t @odony
Useful tool for watching activity: pg_activity
top-like command-line utility to watch queries: running,
blocking, waiting
→ pip install pg_activity
Thanks to @cmorisse for this pointer! :-)

t @odony
Useful VIEW to watch Locks per transaction
# – For PostgreSQL 9.1
# CREATE VIEW monitor_locks AS
SELECT pg_stat_activity.procpid, pg_class.relname, pg_locks.locktype,
pg_locks.transactionid, pg_locks.virtualxid,
pg_locks.virtualtransaction, pg_locks.mode, pg_locks.granted,
pg_stat_activity.usename,
substr(pg_stat_activity.current_query,1,30) AS query,
pg_stat_activity.query_start, age(now(),pg_stat_activity.query_start)
AS duration
FROM pg_stat_activity, pg_locks
LEFT JOIN pg_class ON pg_locks.relation = pg_class.oid
WHERE pg_locks.pid = pg_stat_activity.procpid AND
pg_stat_activity.procpid != pg_backend_pid()
ORDER BY pg_stat_activity.procpid, pg_locks.granted, pg_class.relname;

t @odony
| mode | granted | query | query_start | duration |
+------------------+---------+--------------------------------+-------------------------------+------------------+
| AccessShareLock | t | <IDLE> in transaction | 2013-06-18 12:53:01.601039+02 | 00:00:00.278826 |
| RowExclusiveLock | t | <IDLE> in transaction | 2013-06-18 12:53:01.601039+02 | 00:00:00.278826 |
| RowShareLock | t | <IDLE> in transaction | 2013-06-18 12:53:01.601039+02 | 00:00:00.278826 |
| RowExclusiveLock | t | <IDLE> in transaction | 2013-06-18 12:53:01.601039+02 | 00:00:00.278826 |
| RowShareLock | t | <IDLE> in transaction | 2013-06-18 12:53:01.601039+02 | 00:00:00.278826 |

t @odony
Normal Values?
● Most RPC requests should be under 200ms
● Most SQL queries should be under 100ms
● One transaction = 100-300 heavyweight locks
Find your own normal values via monitoring!

t @odony
Common Problems
● Stored functions
● Slow Queries/Views, Suboptimal domains
● Lock contention
● Custom locking mechanisms (queues, locks,...)

t @odony
Common Problems: Stored Functions
● Stored functional fields are triggers
● Store triggers can be:
●
store = { 'trigger_model': (mapping_function,
['trigger_field1', 'trigger_field2'],
priority) }
● store=True meaning:
self._name (lambda s,c,u,ids,c: ids, None, 10)}→
● Can be very expensive with wrong parameters or
slow functions

t @odony
Common Problems: Slow Queries
●
All SQL queries 500ms+ should be analyzed
●
Use EXPLAIN ANALYZE to examine/measure you custom
SQL queries and VIEWs
●
Try to remove parts of the query until it's fast, then fix it
●
Check cardinality of big JOINs
●
Default domain evaluation strategy
●
search([('picking_id.move_ids.partner_id', '!=', False)])
●
Implemented by combining “id IN (….)” parts
●
Have a look at _auto_join in OpenERP 7.0
'move_ids': fields.one2many('stock.move', 'picking_id',
string='Moves', _auto_join=True)

t @odony
Common Problems: Slow Queries
● No premature optimization: don't write SQL,
use the ORM always during initial
development
● If you detect a hot spot with load-tests,
consider rewriting the inefficient parts in SQL
● But:
● Make sure you're not bypassing security mechanisms
● Don't create SQL injection vectors use query parameters,→
don't concatenate user input in your SQL strings.

t @odony
Common Problems: Lock Contention
●
PostgreSQL guarantees transactional data integrity by
taking heavy-weight locks → monitor_locks
●
Updating a record blocks all FK locks on it until the
transaction is completed!
●
This will change with PostgreSQL 9.3 :-)
●
This is independent from the transaction isolation level
(Repeatable Read/Serializable/...)
→ Don't have long-running transactions!
→ Avoid updating “master data” resources in them!
(user, company, stock location, product, …)

t @odony
Common Problems: Custom Locking
●
Any kind of manual locking/queuing mechanism
is dangerous, especially in Python
●
Python locks can cause deadlocks that cannot
be detected and broken by the system!
●
Avoid it, and if you must, use the database as
lock
●
That's what scheduled jobs (ir.cron) do:
●
SELECT FOR UPDATE on the cron job row
●
→ Automatic cleanup/release
●
→ Scales well and works in multi-process!

t @odony
Avoid Anti-Patterns: Master the framework!
●
Make sure you really understand the browse()
mechanisms!
●
Make sure you properly use the batch API
●
Don't write SQL unless you have to, e.g for:
●
Analysis views
●
Hot spot functions, name_search(), computed_fields(), ...

t @odony
Anti-Patterns: what's wrong?
browse() must be used on lists to benefit from its optimizations!

t @odony
Anti-Patterns: what's wrong now?
browse() use is OK now, but the related field is dangerous
and costly, going through a possibly very large o2m just to find
a single product ID

t @odony
Anti-Patterns: what's wrong here?
The trigger on stock.move is for all fields which means it will
trigger for each change, while we only care about tracking_id
here

Tips on how to improve the performance of your custom modules for high volumes deployment. Olivier Dony, OpenERP

More Related Content

What's hot (20)

Similar to Tips on how to improve the performance of your custom modules for high volumes deployment. Olivier Dony, OpenERP (20)

More from Odoo (20)

Recently uploaded (20)

Tips on how to improve the performance of your custom modules for high volumes deployment. Olivier Dony, OpenERP