--- title: Setting Up Database Monitoring for self hosted Postgres description: Install and configure Database Monitoring for self-hosted Postgres. breadcrumbs: >- Docs > Database Monitoring > Setting up Postgres > Setting Up Database Monitoring for self hosted Postgres --- # Setting Up Database Monitoring for self hosted Postgres Database Monitoring provides deep visibility into your Postgres databases by exposing query metrics, query samples, explain plans, database states, failovers, and events. The Agent collects telemetry directly from the database by logging in as a read-only user. Do the following setup to enable Database Monitoring with your Postgres database: 1. Configure database parameters 1. Grant the Agent access to the database 1. Install the Agent ## Before you begin{% #before-you-begin %} {% dl %} {% dt %} Supported PostgreSQL versions {% /dt %} {% dd %} 9.6, 10, 11, 12, 13, 14, 15, 16, 17, 18 {% /dd %} {% dt %} Prerequisites {% /dt %} {% dd %} Postgres additional supplied modules must be installed. For most installations, this is included by default but less conventional installations might require an additional installation of your version of [the `postgresql-contrib` package](https://www.postgresql.org/docs/current/contrib.html). {% /dd %} {% dt %} Supported Agent versions {% /dt %} {% dd %} 7.36.1+ {% /dd %} {% dt %} Performance impact {% /dt %} {% dd %} The default Agent configuration for Database Monitoring is conservative, but you can adjust settings such as the collection interval and query sampling rate to better suit your needs. For most workloads, the Agent represents less than one percent of query execution time on the database and less than one percent of CPU.Database Monitoring runs as an integration on top of the base Agent ([see benchmarks](https://docs.datadoghq.com/database_monitoring/agent_integration_overhead/?tab=postgres)). {% /dd %} {% dt %} Proxies, load balancers, and connection poolers {% /dt %} {% dd %} The Datadog Agent must connect directly to the host being monitored. For self-hosted databases, `127.0.0.1` or the socket is preferred. The Agent should not connect to the database through a proxy, load balancer, or connection pooler such as `pgbouncer`. If the Agent connects to different hosts while it is running (as in the case of failover, load balancing, and so on), the Agent calculates the difference in statistics between two hosts, producing inaccurate metrics. {% /dd %} {% dt %} Data security considerations {% /dt %} {% dd %} See [Sensitive information](https://docs.datadoghq.com/database_monitoring/data_collected/#sensitive-information) for information about what data the Agent collects from your databases and how to ensure it is secure. {% /dd %} {% /dl %} ## Configure Postgres settings{% #configure-postgres-settings %} Configure the following [parameters](https://www.postgresql.org/docs/current/config-setting.html) in the `postgresql.conf` file and then **restart the server** for the settings to take effect. For more information about these parameters, see the [Postgres documentation](https://www.postgresql.org/docs/current/pgstatstatements.html). | Parameter | Value | Description | | ---------------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `shared_preload_libraries` | `pg_stat_statements` | Required for `postgresql.queries.*` metrics. Enables collection of query metrics using the [pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) extension. | | `track_activity_query_size` | `4096` | Required for collection of larger queries. Increases the size of SQL text in `pg_stat_activity`. If left at the default value then queries longer than `1024` characters will not be collected. | | `pg_stat_statements.track` | `ALL` | Optional. Enables tracking of statements within stored procedures and functions. | | `pg_stat_statements.max` | `10000` | Optional. Increases the number of normalized queries tracked in `pg_stat_statements`. This setting is recommended for high-volume databases that see many different types of queries from many different clients. | | `pg_stat_statements.track_utility` | `off` | Optional. Disables utility commands like PREPARE and EXPLAIN. Setting this value to `off` means only queries like SELECT, UPDATE, and DELETE are tracked. | | `track_io_timing` | `on` | Optional. Enables collection of block read and write times for queries. | ## Grant the Agent access{% #grant-the-agent-access %} The Datadog Agent requires read-only access to the database server in order to collect statistics and queries. The following SQL commands should be executed on the **primary** database server (the writer) in the cluster if Postgres is replicated. Choose a PostgreSQL database on the database server for the Agent to connect to. The Agent can collect telemetry from all databases on the database server regardless of which one it connects to, so a good option is to use the default `postgres` database. Choose a different database only if you need the Agent to run [custom queries against data unique to that database](https://docs.datadoghq.com/integrations/faq/postgres-custom-metric-collection-explained/). Connect to the chosen database as a superuser (or another user with sufficient permissions). For example, if your chosen database is `postgres`, connect as the `postgres` user using [psql](https://www.postgresql.org/docs/current/app-psql.html) by running: ```bash psql -h mydb.example.com -d postgres -U postgres ``` Create the `datadog` user: ```SQL CREATE USER datadog WITH password ''; ``` {% tab title="Postgres ≥ 15" %} Give the `datadog` user permission to relevant tables: ```SQL ALTER ROLE datadog INHERIT; ``` Create the following schema **in every database**: ```SQL CREATE SCHEMA datadog; GRANT USAGE ON SCHEMA datadog TO datadog; GRANT USAGE ON SCHEMA public TO datadog; GRANT pg_monitor TO datadog; CREATE EXTENSION IF NOT EXISTS pg_stat_statements; ``` {% /tab %} {% tab title="Postgres ≥ 10" %} Create the following schema **in every database**: ```SQL CREATE SCHEMA datadog; GRANT USAGE ON SCHEMA datadog TO datadog; GRANT USAGE ON SCHEMA public TO datadog; GRANT pg_monitor TO datadog; CREATE EXTENSION IF NOT EXISTS pg_stat_statements; ``` {% /tab %} {% tab title="Postgres 9.6" %} Create the following schema **in every database**: ```SQL CREATE SCHEMA datadog; GRANT USAGE ON SCHEMA datadog TO datadog; GRANT USAGE ON SCHEMA public TO datadog; GRANT SELECT ON pg_stat_database TO datadog; CREATE EXTENSION IF NOT EXISTS pg_stat_statements; ``` Create functions **in every database** to enable the Agent to read the full contents of `pg_stat_activity` and `pg_stat_statements`: ```SQL CREATE OR REPLACE FUNCTION datadog.pg_stat_activity() RETURNS SETOF pg_stat_activity AS $$ SELECT * FROM pg_catalog.pg_stat_activity; $$ LANGUAGE sql SECURITY DEFINER; CREATE OR REPLACE FUNCTION datadog.pg_stat_statements() RETURNS SETOF pg_stat_statements AS $$ SELECT * FROM pg_stat_statements; $$ LANGUAGE sql SECURITY DEFINER; ``` {% /tab %} {% alert level="info" %} For data collection or custom metrics that require querying additional tables, you may need to grant the `SELECT` permission on those tables to the `datadog` user. Example: `grant SELECT on to datadog;`. See [PostgreSQL custom metric collection](https://docs.datadoghq.com/integrations/faq/postgres-custom-metric-collection-explained/) for more information. {% /alert %} Create the function **in every database** to enable the Agent to collect explain plans. ```SQL CREATE OR REPLACE FUNCTION datadog.explain_statement( l_query TEXT, OUT explain JSON ) RETURNS SETOF JSON AS $$ DECLARE curs REFCURSOR; plan JSON; BEGIN SET TRANSACTION READ ONLY; OPEN curs FOR EXECUTE pg_catalog.concat('EXPLAIN (FORMAT JSON) ', l_query); FETCH curs INTO plan; CLOSE curs; RETURN QUERY SELECT plan; END; $$ LANGUAGE 'plpgsql' RETURNS NULL ON NULL INPUT SECURITY DEFINER; ``` ### Securely store your password{% #securely-store-your-password %} Store your password using secret management software such as [Vault](https://www.vaultproject.io/). You can then reference this password as `ENC[]` in your Agent configuration files: for example, `ENC[datadog_user_database_password]`. See [Secrets Management](https://docs.datadoghq.com/agent/configuration/secrets-management/) for more information. The examples on this page use `datadog_user_database_password` to refer to the name of the secret where your password is stored. It is possible to reference your password in plain text, but this is not recommended. ### Verify{% #verify %} To verify the permissions are correct, run the following commands to confirm the Agent user is able to connect to the database and read the core tables: {% tab title="Postgres ≥ 10" %} ```shell psql -h localhost -U datadog postgres -A \ -c "select * from pg_stat_database limit 1;" \ && echo -e "\e[0;32mPostgres connection - OK\e[0m" \ || echo -e "\e[0;31mCannot connect to Postgres\e[0m" psql -h localhost -U datadog postgres -A \ -c "select * from pg_stat_activity limit 1;" \ && echo -e "\e[0;32mPostgres pg_stat_activity read OK\e[0m" \ || echo -e "\e[0;31mCannot read from pg_stat_activity\e[0m" psql -h localhost -U datadog postgres -A \ -c "select * from pg_stat_statements limit 1;" \ && echo -e "\e[0;32mPostgres pg_stat_statements read OK\e[0m" \ || echo -e "\e[0;31mCannot read from pg_stat_statements\e[0m" ``` {% /tab %} {% tab title="Postgres 9.6" %} ```shell psql -h localhost -U datadog postgres -A \ -c "select * from pg_stat_database limit 1;" \ && echo -e "\e[0;32mPostgres connection - OK\e[0m" \ || echo -e "\e[0;31mCannot connect to Postgres\e[0m" psql -h localhost -U datadog postgres -A \ -c "select * from pg_stat_activity limit 1;" \ && echo -e "\e[0;32mPostgres pg_stat_activity read OK\e[0m" \ || echo -e "\e[0;31mCannot read from pg_stat_activity\e[0m" psql -h localhost -U datadog postgres -A \ -c "select * from pg_stat_statements limit 1;" \ && echo -e "\e[0;32mPostgres pg_stat_statements read OK\e[0m" \ || echo -e "\e[0;31mCannot read from pg_stat_statements\e[0m" ``` {% /tab %} When it prompts for a password, use the password you entered when you created the `datadog` user. ## Install the Agent{% #install-the-agent %} Installing the Datadog Agent also installs the Postgres check, which is required for Database Monitoring on Postgres. If you haven't installed the Agent, see the [Agent installation instructions](https://app.datadoghq.com/account/settings/agent/latest). Then, return here to continue with the instructions for your installation method. Edit the Agent's `conf.d/postgres.d/conf.yaml` file to point to the Postgres instance you want to monitor. For a complete list of configuration options, see the [sample postgres.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/postgres/datadog_checks/postgres/data/conf.yaml.example). ```yaml init_config: instances: - dbm: true host: localhost port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' ## Optional: Connect to a different database if needed for `custom_queries` # dbname: '' ``` **Note**: If your password includes special characters, wrap it in single quotes. [Restart the Agent](https://docs.datadoghq.com/agent/configuration/agent-commands/#restart-the-agent) to apply the changes. ### Collecting logs (optional){% #collecting-logs-optional %} PostgreSQL default logging is to `stderr`, and logs do not include detailed information. It is recommended to log into a file with additional details specified in the log line prefix. Refer to the PostgreSQL [documentation](https://www.postgresql.org/docs/11/runtime-config-logging.html) on this topic for additional details. 1. Logging is configured within the file `/etc/postgresql//main/postgresql.conf`. For regular log results, including statement outputs, set the following parameters in the log section: ``` logging_collector = on log_line_prefix = '%m [%p] %d %a %u %h %c ' # this pattern is required to correlate metrics in the Datadog product log_file_mode = 0644 ## For Windows #log_destination = 'eventlog' ``` 1. To gather detailed duration metrics and make them searchable in the Datadog interface, they should be configured inline with the statement themselves. See below for the recommended configuration differences from above and note that both `log_statement` and `log_duration` options are commented out. See discussion on this topic [here](https://www.postgresql.org/message-id/20100210180532.GA20138@depesz.com). This config logs all statements, but to reduce the output to those which have a certain duration, set the `log_min_duration_statement` value to the desired minimum duration in milliseconds (check that logging the full SQL statement complies with your organization's privacy requirements): ``` log_min_duration_statement = 0 # -1 is disabled, 0 logs all statements # and their durations, > 0 logs only # statements running at least this number # of milliseconds #log_statement = 'all' #log_duration = on ``` 1. Collecting logs is disabled by default in the Datadog Agent, enable it in your `datadog.yaml` file: ```yaml logs_enabled: true ``` 1. Add and edit this configuration block to your `conf.d/postgres.d/conf.yaml` file to start collecting your PostgreSQL logs: ```yaml logs: - type: file path: "" source: postgresql service: "" #To handle multi line that starts with yyyy-mm-dd use the following pattern #log_processing_rules: # - type: multi_line # pattern: \d{4}\-(0?[1-9]|1[012])\-(0?[1-9]|[12][0-9]|3[01]) # name: new_log_start_with_date ``` Change the `service` and `path` parameter values to configure for your environment. See the [sample postgres.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/postgres/datadog_checks/postgres/data/conf.yaml.example) for all available configuration options. 1. [Restart the Agent](https://docs.datadoghq.com/agent/configuration/agent-commands/#start-stop-and-restart-the-agent). ### Collecting plans with `auto_explain` (optional){% #collecting-plans-with-auto_explain-optional %} By default, the agent only gathers [`EXPLAIN`](https://www.postgresql.org/docs/current/sql-explain.html) plans for a sampling of in-flight queries. These plans are of a more general nature, especially when application code uses prepared statements. To collect full `EXPLAIN ANALYZE` plans taken from all queries, you need to use [`auto_explain`](https://www.postgresql.org/docs/current/auto-explain.html), a first-party extension bundled with PostgreSQL available in all major providers. *Logging collection is a prerequisite to `auto_explain` collection*, so be sure to enable it before continuing. {% alert level="danger" %} **Important:** `auto_explain` produces logs lines that may contain sensitive information from your application, similar to the raw values that appear in non-obfuscated SQL. You can use the [`dbm_parameterized_queries_read`](https://docs.datadoghq.com/account_management/rbac/permissions/#database-monitoring) permission to control who can see the resulting plans, but the log lines themselves are visible to all users within your Datadog org. Using [RBAC for Logs](https://docs.datadoghq.com/logs/guide/logs-rbac) helps ensure these logs are only visible to the right users. {% /alert %} After you enable logging collection: 1. Add `auto_explain` to your list of `shared_preload_libraries` in `postgresql.conf`. For instance, if `shared_preload_libraries` is set to `pg_stat_statements`, change it to `pg_stat_statements,auto_explain` 1. Change the `log_line_prefix` to enable richer event correlation. This pattern is required to ingest auto_explain plans. ``` log_line_prefix = '%m:%r:%u@%d:[%p]:%l:%e:%s:%v:%x:%c:%q%a:' ``` 1. Configure `auto_explain` settings. The log format *must* be `json`, but other settings can vary depending on your application. This example logs an `EXPLAIN ANALYZE` plan for all queries over one second, including buffer information but omitting timing (which can have overhead). ``` auto_explain.log_format: "json" auto_explain.log_min_duration: "1000" auto_explain.log_analyze: "on" auto_explain.log_buffers: "on" auto_explain.log_timing: "off" auto_explain.log_triggers: "on" auto_explain.log_verbose: "on" auto_explain.log_nested_statements: "on" auto_explain.sample_rate: "1" ``` 1. [Restart the Agent](https://docs.datadoghq.com/agent/configuration/agent-commands/#start-stop-and-restart-the-agent). ### Validate{% #validate %} [Run the Agent's status subcommand](https://docs.datadoghq.com/agent/configuration/agent-commands/#agent-status-and-information) and look for `postgres` under the Checks section. Or visit the [Databases](https://app.datadoghq.com/databases) page to get started! ## Example Agent Configurations{% #example-agent-configurations %} ### One agent connecting to multiple hosts{% #one-agent-connecting-to-multiple-hosts %} It is common to configure a single Agent host to connect to multiple remote database instances (see [Agent installation architectures](https://docs.datadoghq.com/database_monitoring/architecture/) for DBM). To connect to multiple hosts, create an entry for each host in the Postgres integration config. {% alert level="info" %} Datadog recommends using one Agent to monitor no more than 30 database instances.Benchmarks show that one Agent running on a t4g.medium EC2 instance (2 CPUs and 4GB of RAM) can successfully monitor 30 RDS db.t3.medium instances (2 CPUs and 4GB of RAM). {% /alert %} ```yaml init_config: instances: - dbm: true host: example-service-primary.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' tags: - 'env:prod' - 'team:team-discovery' - 'service:example-service' - dbm: true host: example-service–replica-1.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' tags: - 'env:prod' - 'team:team-discovery' - 'service:example-service' - dbm: true host: example-service–replica-2.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' tags: - 'env:prod' - 'team:team-discovery' - 'service:example-service' [...] ``` ### Monitoring multiple databases on a database host{% #monitoring-multiple-databases-on-a-database-host %} Use the `database_autodiscovery` option to permit the Agent to discover all databases on your host to monitor. You can specify `include` or `exclude` fields to narrow the scope of databases discovered. See the sample [postgres.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/postgres/datadog_checks/postgres/data/conf.yaml.example) for more details. ```yaml init_config: instances: - dbm: true host: example-service-primary.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' database_autodiscovery: enabled: true # Optionally, set the include field to specify # a set of databases you are interested in discovering include: - mydb.* - example.* tags: - 'env:prod' - 'team:team-discovery' - 'service:example-service' ``` ### Running custom queries{% #running-custom-queries %} To collect custom metrics, use the `custom_queries` option. See the sample [postgres.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/postgres/datadog_checks/postgres/data/conf.yaml.example) for more details. ```yaml init_config: instances: - dbm: true host: localhost port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' custom_queries: - metric_prefix: employee query: SELECT age, salary, hours_worked, name FROM hr.employees; columns: - name: custom.employee_age type: gauge - name: custom.employee_salary type: gauge - name: custom.employee_hours type: count - name: name type: tag tags: - 'table:employees' ``` ### Monitoring relation metrics for multiple databases{% #monitoring-relation-metrics-for-multiple-databases %} In order to collect relation metrics (such as `postgresql.seq_scans`, `postgresql.dead_rows`, `postgresql.index_rows_read`, and `postgresql.table_size`), the Agent must be configured to connect to each database (by default, the Agent only connects to the `postgres` database). Specify a single "DBM" instance to collect DBM telemetry from all databases. Use the `database_autodiscovery` option to avoid specifying each database name. ```yaml init_config: instances: # This instance is the "DBM" instance. It will connect to the # all logical databases, and send DBM telemetry from all databases - dbm: true host: example-service-primary.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' database_autodiscovery: enabled: true exclude: - ^users$ - ^inventory$ relations: - relation_regex: .* # This instance only collects data from the `users` database # and collects relation metrics from tables prefixed by "2022_" - host: example-service-primary.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' dbname: users dbstrict: true relations: - relation_regex: 2022_.* relkind: - r - i # This instance only collects data from the `inventory` database # and collects relation metrics only from the specified tables - host: example-service-primary.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' dbname: inventory dbstrict: true relations: - relation_name: products - relation_name: external_seller_products ``` ### Collecting schemas{% #collecting-schemas %} To enable this feature, use the `collect_schemas` option. You must also configure the Agent to connect to each logical database. Use the `database_autodiscovery` option to avoid specifying each logical database. See the sample [postgres.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/postgres/datadog_checks/postgres/data/conf.yaml.example) for more details. ```yaml init_config: # This instance only collects data from the `users` database # and collects relation metrics only from the specified tables instances: - dbm: true host: example-service-primary.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' dbname: users dbstrict: true collect_schemas: enabled: true relations: - products - external_seller_products # This instance detects every logical database automatically # and collects relation metrics from every table - dbm: true host: example-service–replica-1.example-host.com port: 5432 username: datadog password: 'ENC[datadog_user_database_password]' database_autodiscovery: enabled: true collect_schemas: enabled: true relations: - relation_regex: .* ``` ### Working with hosts through a proxy{% #working-with-hosts-through-a-proxy %} If the Agent must connect through a proxy such as the [Cloud SQL Auth proxy](https://cloud.google.com/sql/docs/mysql/connect-admin-proxy), all telemetry is tagged with the hostname of the proxy rather than the database instance. Use the `reported_hostname` option to set a custom override of the hostname detected by the Agent. ```yaml init_config: instances: - dbm: true host: localhost port: 5000 username: datadog password: 'ENC[datadog_user_database_password]' reported_hostname: example-service-primary - dbm: true host: localhost port: 5001 username: datadog password: 'ENC[datadog_user_database_password]' reported_hostname: example-service-replica-1 ``` ## Troubleshooting{% #troubleshooting %} If you have installed and configured the integrations and Agent as described and it is not working as expected, see [Troubleshooting](https://docs.datadoghq.com/database_monitoring/troubleshooting/?tab=postgres) ## Further reading{% #further-reading %} - [Basic Postgres Integration](https://docs.datadoghq.com/integrations/postgres/) - [Capturing SQL Query Parameter Values](https://docs.datadoghq.com/database_monitoring/guide/parameterized_queries/) - [Debug PostgreSQL query latency faster with EXPLAIN ANALYZE in Datadog Database Monitoring](https://www.datadoghq.com/blog/database-monitoring-explain-analyze)