diff --git a/manifests/globals.pp b/manifests/globals.pp
index f3ad15f..5349b3c 100644
--- a/manifests/globals.pp
+++ b/manifests/globals.pp
@@ -1,151 +1,152 @@
 # Class for setting cross-class global overrides. See README.md for more
 # details.
 class postgresql::globals (
   $client_package_name      = undef,
   $server_package_name      = undef,
   $contrib_package_name     = undef,
   $devel_package_name       = undef,
   $java_package_name        = undef,
   $docs_package_name        = undef,
   $perl_package_name        = undef,
   $plperl_package_name      = undef,
   $plpython_package_name    = undef,
   $python_package_name      = undef,
   $postgis_package_name     = undef,
 
   $service_name             = undef,
   $service_provider         = undef,
   $service_status           = undef,
   $default_database         = undef,
 
   $validcon_script_path     = undef,
 
   $initdb_path              = undef,
   $createdb_path            = undef,
   $psql_path                = undef,
   $pg_hba_conf_path         = undef,
   $pg_ident_conf_path       = undef,
   $postgresql_conf_path     = undef,
   $recovery_conf_path       = undef,
   $default_connect_settings = {},
 
   $pg_hba_conf_defaults     = undef,
 
   $datadir                  = undef,
   $confdir                  = undef,
   $bindir                   = undef,
   $xlogdir                  = undef,
   $logdir                   = undef,
+  $log_line_prefix          = undef,
 
   $user                     = undef,
   $group                    = undef,
 
   $version                  = undef,
   $postgis_version          = undef,
   $repo_proxy               = undef,
 
   $needs_initdb             = undef,
 
   $encoding                 = undef,
   $locale                   = undef,
 
   $manage_pg_hba_conf       = undef,
   $manage_pg_ident_conf     = undef,
   $manage_recovery_conf     = undef,
 
   $manage_package_repo      = undef,
 ) {
   # We are determining this here, because it is needed by the package repo
   # class.
   $default_version = $::osfamily ? {
     /^(RedHat|Linux)/ => $::operatingsystem ? {
       'Fedora' => $::operatingsystemrelease ? {
         /^(22)$/ => '9.4',
         /^(21)$/ => '9.3',
         /^(18|19|20)$/ => '9.2',
         /^(17)$/ => '9.1',
         default => undef,
       },
       'Amazon' => '9.2',
       default => $::operatingsystemrelease ? {
         /^7\./ => '9.2',
         /^6\./ => '8.4',
         /^5\./ => '8.1',
         default => undef,
       },
       default => $::operatingsystemrelease ? {
         /^7\./ => '9.2',
         /^6\./ => '8.4',
         /^5\./ => '8.1',
         default => undef,
       },
     },
     'Debian' => $::operatingsystem ? {
       'Debian' => $::operatingsystemrelease ? {
         /^6\./ => '8.4',
         /^(wheezy|7\.)/ => '9.1',
         /^(jessie|8\.)/ => '9.4',
         default => undef,
       },
       'Ubuntu' => $::operatingsystemrelease ? {
         /^(10.04|10.10|11.04)$/ => '8.4',
         /^(11.10|12.04|12.10|13.04|13.10)$/ => '9.1',
         /^(14.04)$/ => '9.3',
         /^(14.10|15.04|15.10)$/ => '9.4',
         /^(16.04)$/ => '9.5',
         default => undef,
       },
       default => undef,
     },
     'Archlinux' => $::operatingsystem ? {
       /Archlinux/ => '9.2',
       default => '9.2',
     },
     'FreeBSD' => '93',
     'OpenBSD' => $::operatingsystemrelease ? {
       /5\.6/ => '9.3',
       /5\.[7-9]/ => '9.4',
     },
     'Suse' => $::operatingsystem ? {
       'SLES' => $::operatingsystemrelease ? {
         /11\.[0-4]/ => '91',
         default => '93',
       },
       'OpenSuSE' => $::operatingsystemrelease ? {
         '13.2' => '93',
       },
       default => undef,
     },
     default => undef,
   }
   $globals_version = pick($version, $default_version, 'unknown')
   if($globals_version == 'unknown') {
     fail('No preferred version defined or automatically detected.')
   }
 
   $default_postgis_version = $globals_version ? {
     '8.1'   => '1.3.6',
     '8.4'   => '1.5',
     '9.0'   => '1.5',
     '9.1'   => '1.5',
     '91'    => '1.5',
     '9.2'   => '2.0',
     '9.3'   => '2.1',
     '93'    => '2.1',
     '9.4'   => '2.1',
     '9.5'   => '2.2',
     default => undef,
   }
   $globals_postgis_version = $postgis_version ? {
     undef   => $default_postgis_version,
     default => $postgis_version,
   }
 
   # Setup of the repo only makes sense globally, so we are doing this here.
   if($manage_package_repo) {
     class { 'postgresql::repo':
       version => $globals_version,
       proxy   => $repo_proxy,
     }
   }
 }
diff --git a/manifests/params.pp b/manifests/params.pp
index cabe9d9..60331f8 100644
--- a/manifests/params.pp
+++ b/manifests/params.pp
@@ -1,272 +1,273 @@
 # PRIVATE CLASS: do not use directly
 class postgresql::params inherits postgresql::globals {
   $version                    = $postgresql::globals::globals_version
   $postgis_version            = $postgresql::globals::globals_postgis_version
   $listen_addresses           = 'localhost'
   $port                       = 5432
+  $log_line_prefix            = '%t '
   $ip_mask_deny_postgres_user = '0.0.0.0/0'
   $ip_mask_allow_all_users    = '127.0.0.1/32'
   $ipv4acls                   = []
   $ipv6acls                   = []
   $encoding                   = $postgresql::globals::encoding
   $locale                     = $postgresql::globals::locale
   $service_ensure             = 'running'
   $service_enable             = true
   $service_manage             = true
   $service_restart_on_change  = true
   $service_provider           = $postgresql::globals::service_provider
   $manage_pg_hba_conf         = pick($manage_pg_hba_conf, true)
   $manage_pg_ident_conf       = pick($manage_pg_ident_conf, true)
   $manage_recovery_conf       = pick($manage_recovery_conf, false)
   $package_ensure             = 'present'
 
   # Amazon Linux's OS Family is 'Linux', operating system 'Amazon'.
   case $::osfamily {
     'RedHat', 'Linux': {
       $link_pg_config     = true
       $user               = pick($user, 'postgres')
       $group              = pick($group, 'postgres')
       $needs_initdb       = pick($needs_initdb, true)
       $version_parts      = split($version, '[.]')
       $package_version    = "${version_parts[0]}${version_parts[1]}"
 
       if $version == $postgresql::globals::default_version and $::operatingsystem != 'Amazon' {
         $client_package_name    = pick($client_package_name, 'postgresql')
         $server_package_name    = pick($server_package_name, 'postgresql-server')
         $contrib_package_name   = pick($contrib_package_name,'postgresql-contrib')
         $devel_package_name     = pick($devel_package_name, 'postgresql-devel')
         $java_package_name      = pick($java_package_name, 'postgresql-jdbc')
         $docs_package_name      = pick($docs_package_name, 'postgresql-docs')
         $plperl_package_name    = pick($plperl_package_name, 'postgresql-plperl')
         $plpython_package_name  = pick($plpython_package_name, 'postgresql-plpython')
         $service_name           = pick($service_name, 'postgresql')
         $bindir                 = pick($bindir, '/usr/bin')
         $datadir                = $::operatingsystem ? {
           'Amazon' => pick($datadir, "/var/lib/pgsql${package_version}/data"),
           default  => pick($datadir, '/var/lib/pgsql/data'),
         }
         $confdir                = pick($confdir, $datadir)
       } else {
         $client_package_name    = pick($client_package_name, "postgresql${package_version}")
         $server_package_name    = pick($server_package_name, "postgresql${package_version}-server")
         $contrib_package_name   = pick($contrib_package_name,"postgresql${package_version}-contrib")
         $devel_package_name     = pick($devel_package_name, "postgresql${package_version}-devel")
         $java_package_name      = pick($java_package_name, "postgresql${package_version}-jdbc")
         $docs_package_name      = pick($docs_package_name, "postgresql${package_version}-docs")
         $plperl_package_name    = pick($plperl_package_name, "postgresql${package_version}-plperl")
         $plpython_package_name  = pick($plpython_package_name, "postgresql${package_version}-plpython")
         $service_name           = $::operatingsystem ? {
           'Amazon' => pick($service_name, "postgresql${version_parts[0]}${version_parts[1]}"),
           default  => pick($service_name, "postgresql-${version}"),
         }
         $bindir                 = $::operatingsystem ? {
           'Amazon' => pick($bindir, '/usr/bin'),
           default  => pick($bindir, "/usr/pgsql-${version}/bin"),
         }
         $datadir                = $::operatingsystem ? {
           'Amazon' => pick($datadir, "/var/lib/pgsql${package_version}/data"),
           default  => pick($datadir, "/var/lib/pgsql/${version}/data"),
         }
         $confdir                = pick($confdir, $datadir)
       }
       $psql_path           = pick($psql_path, "${bindir}/psql")
 
       $service_status      = $service_status
       $service_reload      = "service ${service_name} reload"
       $perl_package_name   = pick($perl_package_name, 'perl-DBD-Pg')
       $python_package_name = pick($python_package_name, 'python-psycopg2')
 
       if $postgresql::globals::postgis_package_name {
         $postgis_package_name = $postgresql::globals::postgis_package_name
       } elsif $::operatingsystemrelease =~ /^5\./ {
         $postgis_package_name = 'postgis'
       } elsif $postgis_version and versioncmp($postgis_version, '2') < 0 {
         $postgis_package_name = "postgis${package_version}"
       } else {
         $postgis_package_name = "postgis2_${package_version}"
       }
     }
 
     'Archlinux': {
       $link_pg_config     = true
       $needs_initdb       = pick($needs_initdb, true)
       $user               = pick($user, 'postgres')
       $group              = pick($group, 'postgres')
 
       # Archlinux doesn't have a client-package but has a libs package which
       # pulls in postgresql server
       $client_package_name    = pick($client_package_name, 'postgresql')
       $server_package_name    = pick($server_package_name, 'postgresql-libs')
       $java_package_name      = pick($java_package_name, 'postgresql-jdbc')
       # Archlinux doesn't have develop packages
       $devel_package_name     = pick($devel_package_name, 'postgresql-devel')
       # Archlinux does have postgresql-contrib but it isn't maintained
       $contrib_package_name   = pick($contrib_package_name,'undef')
       # Archlinux postgresql package provides plperl
       $plperl_package_name    = pick($plperl_package_name, 'undef')
       $plpython_package_name  = pick($plpython_package_name, 'undef')
       $service_name           = pick($service_name, 'postgresql')
       $bindir                 = pick($bindir, '/usr/bin')
       $datadir                = pick($datadir, '/var/lib/postgres/data')
       $confdir                = pick($confdir, $datadir)
       $psql_path              = pick($psql_path, "${bindir}/psql")
 
       $service_status         = $service_status
       $service_reload         = "systemctl reload ${service_name}"
       $python_package_name    = pick($python_package_name, 'python-psycopg2')
       # Archlinux does not have a perl::DBD::Pg package
       $perl_package_name      = pick($perl_package_name, 'undef')
     }
 
     'Debian': {
       $link_pg_config     = false
       $user               = pick($user, 'postgres')
       $group              = pick($group, 'postgres')
 
       if $postgresql::globals::manage_package_repo == true {
         $needs_initdb = pick($needs_initdb, true)
         $service_name = pick($service_name, 'postgresql')
       } else {
         $needs_initdb = pick($needs_initdb, false)
         $service_name = $::operatingsystem ? {
           'Debian' => pick($service_name, 'postgresql'),
           'Ubuntu' => $::lsbmajdistrelease ? {
             /^10/ => pick($service_name, "postgresql-${version}"),
             default => pick($service_name, 'postgresql'),
           },
           default => undef
         }
       }
 
       $client_package_name    = pick($client_package_name, "postgresql-client-${version}")
       $server_package_name    = pick($server_package_name, "postgresql-${version}")
       $contrib_package_name   = pick($contrib_package_name, "postgresql-contrib-${version}")
       if $postgis_version and versioncmp($postgis_version, '2') < 0 {
         $postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis")
       } else {
         $postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis-${postgis_version}")
       }
       $devel_package_name     = pick($devel_package_name, 'libpq-dev')
       $java_package_name      = pick($java_package_name, 'libpostgresql-jdbc-java')
       $perl_package_name      = pick($perl_package_name, 'libdbd-pg-perl')
       $plperl_package_name    = pick($plperl_package_name, "postgresql-plperl-${version}")
       $plpython_package_name  = pick($plpython_package_name, "postgresql-plpython-${version}")
       $python_package_name    = pick($python_package_name, 'python-psycopg2')
 
       $bindir                 = pick($bindir, "/usr/lib/postgresql/${version}/bin")
       $datadir                = pick($datadir, "/var/lib/postgresql/${version}/main")
       $confdir                = pick($confdir, "/etc/postgresql/${version}/main")
       if $::operatingsystem == 'Debian' and versioncmp($::operatingsystemrelease, '8.0') >= 0 {
         # Jessie uses systemd
         $service_status = pick($service_status, "/usr/sbin/service ${service_name}@*-main status")
       } elsif $::operatingsystem == 'Ubuntu' and versioncmp($::operatingsystemrelease, '15.04') >= 0 {
         # Ubuntu releases since vivid use systemd
         $service_status = pick($service_status, "/usr/sbin/service ${service_name} status")
       } else {
         $service_status = pick($service_status, "/etc/init.d/${service_name} status | /bin/egrep -q 'Running clusters: .+|online'")
       }
       $service_reload         = "service ${service_name} reload"
       $psql_path              = pick($psql_path, '/usr/bin/psql')
     }
 
     'FreeBSD': {
       $link_pg_config       = true
       $user                 = pick($user, 'pgsql')
       $group                = pick($group, 'pgsql')
 
       $client_package_name  = pick($client_package_name, "databases/postgresql${version}-client")
       $server_package_name  = pick($server_package_name, "databases/postgresql${version}-server")
       $contrib_package_name = pick($contrib_package_name, "databases/postgresql${version}-contrib")
       $devel_package_name   = pick($devel_package_name, 'databases/postgresql-libpqxx3')
       $java_package_name    = pick($java_package_name, 'databases/postgresql-jdbc')
       $perl_package_name    = pick($plperl_package_name, 'databases/p5-DBD-Pg')
       $plperl_package_name  = pick($plperl_package_name, "databases/postgresql${version}-plperl")
       $python_package_name  = pick($python_package_name, 'databases/py-psycopg2')
 
       $service_name         = pick($service_name, 'postgresql')
       $bindir               = pick($bindir, '/usr/local/bin')
       $datadir              = pick($datadir, '/usr/local/pgsql/data')
       $confdir              = pick($confdir, $datadir)
       $service_status       = pick($service_status, "/usr/local/etc/rc.d/${service_name} onestatus")
       $service_reload       = "service ${service_name} reload"
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     'OpenBSD': {
       $user                = pick($user, '_postgresql')
       $group               = pick($group, '_postgresql')
 
       $client_package_name  = pick($client_package_name, 'postgresql-client')
       $server_package_name  = pick($server_package_name, 'postgresql-server')
       $contrib_package_name = pick($contrib_package_name, 'postgresql-contrib')
       $devel_package_name   = pick($devel_package_name, 'postgresql-client')
       $java_package_name    = pick($java_package_name, 'postgresql-jdbc')
       $perl_package_name    = pick($perl_package_name, 'databases/p5-DBD-Pg')
       $plperl_package_name  = undef
       $python_package_name  = pick($python_package_name, 'py-psycopg2')
 
       $service_name         = pick($service_name, 'postgresql')
       $bindir               = pick($bindir, '/usr/local/bin')
       $datadir              = pick($datadir, '/var/postgresql/data')
       $confdir              = pick($confdir, $datadir)
       $service_status       = pick($service_status, "/etc/rc.d/${service_name} check")
       $service_reload       = "/etc/rc.d/${service_name} reload"
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     'Suse': {
       $link_pg_config       = true
       $user                 = pick($user, 'postgres')
       $group                = pick($group, 'postgres')
 
       $client_package_name  = pick($client_package_name, "postgresql${version}")
       $server_package_name  = pick($server_package_name, "postgresql${version}-server")
       $contrib_package_name = pick($contrib_package_name, "postgresql${version}-contrib")
       $devel_package_name   = pick($devel_package_name, "postgresql${version}-devel")
       $java_package_name    = pick($java_package_name, "postgresql${version}-jdbc")
       $perl_package_name    = pick($plperl_package_name, 'perl-DBD-Pg')
       $plperl_package_name  = pick($plperl_package_name, "postgresql${version}-plperl")
       $python_package_name  = pick($python_package_name, 'python-psycopg2')
 
       $service_name         = pick($service_name, 'postgresql')
       $bindir               = pick($bindir, "/usr/lib/postgresql${version}/bin")
       $datadir              = pick($datadir, '/var/lib/pgsql/data')
       $confdir              = pick($confdir, $datadir)
       $service_status       = pick($service_status, "/etc/init.d/${service_name} status")
       $service_reload       = "/etc/init.d/${service_name} reload"
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     default: {
       $link_pg_config       = true
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       # Since we can't determine defaults on our own, we rely on users setting
       # parameters with the postgresql::globals class. Here we are checking
       # that the mandatory minimum is set for the module to operate.
       $err_prefix = "Module ${module_name} does not provide defaults for osfamily: ${::osfamily} operatingsystem: ${::operatingsystem}; please specify a value for ${module_name}::globals::"
       if ($needs_initdb == undef) { fail("${err_prefix}needs_initdb") }
       if ($service_name == undef) { fail("${err_prefix}service_name") }
       if ($client_package_name == undef) { fail("${err_prefix}client_package_name") }
       if ($server_package_name == undef) { fail("${err_prefix}server_package_name") }
       if ($bindir == undef) { fail("${err_prefix}bindir") }
       if ($datadir == undef) { fail("${err_prefix}datadir") }
       if ($confdir == undef) { fail("${err_prefix}confdir") }
     }
   }
 
   $validcon_script_path = pick($validcon_script_path, '/usr/local/bin/validate_postgresql_connection.sh')
   $initdb_path          = pick($initdb_path, "${bindir}/initdb")
   $pg_hba_conf_path     = pick($pg_hba_conf_path, "${confdir}/pg_hba.conf")
   $pg_hba_conf_defaults = pick($pg_hba_conf_defaults, true)
   $pg_ident_conf_path   = pick($pg_ident_conf_path, "${confdir}/pg_ident.conf")
   $postgresql_conf_path = pick($postgresql_conf_path, "${confdir}/postgresql.conf")
   $recovery_conf_path   = pick($recovery_conf_path, "${datadir}/recovery.conf")
   $default_database     = pick($default_database, 'postgres')
 }
diff --git a/manifests/server.pp b/manifests/server.pp
index 99b87fd..f4fa2f4 100644
--- a/manifests/server.pp
+++ b/manifests/server.pp
@@ -1,81 +1,83 @@
 # This installs a PostgreSQL server. See README.md for more details.
 class postgresql::server (
   $postgres_password          = undef,
 
   $package_name               = $postgresql::params::server_package_name,
   $client_package_name        = $postgresql::params::client_package_name,
   $package_ensure             = $postgresql::params::package_ensure,
 
   $plperl_package_name        = $postgresql::params::plperl_package_name,
   $plpython_package_name      = $postgresql::params::plpython_package_name,
 
   $service_ensure             = $postgresql::params::service_ensure,
   $service_enable             = $postgresql::params::service_enable,
   $service_manage             = $postgresql::params::service_manage,
   $service_name               = $postgresql::params::service_name,
   $service_restart_on_change  = $postgresql::params::service_restart_on_change,
   $service_provider           = $postgresql::params::service_provider,
   $service_reload             = $postgresql::params::service_reload,
   $service_status             = $postgresql::params::service_status,
   $default_database           = $postgresql::params::default_database,
   $default_connect_settings   = $postgresql::globals::default_connect_settings,
   $listen_addresses           = $postgresql::params::listen_addresses,
   $port                       = $postgresql::params::port,
   $ip_mask_deny_postgres_user = $postgresql::params::ip_mask_deny_postgres_user,
   $ip_mask_allow_all_users    = $postgresql::params::ip_mask_allow_all_users,
   $ipv4acls                   = $postgresql::params::ipv4acls,
   $ipv6acls                   = $postgresql::params::ipv6acls,
 
   $initdb_path                = $postgresql::params::initdb_path,
   $createdb_path              = $postgresql::params::createdb_path,
   $psql_path                  = $postgresql::params::psql_path,
   $pg_hba_conf_path           = $postgresql::params::pg_hba_conf_path,
   $pg_ident_conf_path         = $postgresql::params::pg_ident_conf_path,
   $postgresql_conf_path       = $postgresql::params::postgresql_conf_path,
   $recovery_conf_path         = $postgresql::params::recovery_conf_path,
 
   $datadir                    = $postgresql::params::datadir,
   $xlogdir                    = $postgresql::params::xlogdir,
   $logdir                     = $postgresql::params::logdir,
 
+  $log_line_prefix            = $postgresql::params::log_line_prefix,
+
   $pg_hba_conf_defaults       = $postgresql::params::pg_hba_conf_defaults,
 
   $user                       = $postgresql::params::user,
   $group                      = $postgresql::params::group,
 
   $needs_initdb               = $postgresql::params::needs_initdb,
 
   $encoding                   = $postgresql::params::encoding,
   $locale                     = $postgresql::params::locale,
 
   $manage_pg_hba_conf         = $postgresql::params::manage_pg_hba_conf,
   $manage_pg_ident_conf       = $postgresql::params::manage_pg_ident_conf,
   $manage_recovery_conf       = $postgresql::params::manage_recovery_conf,
 
   #Deprecated
   $version                    = undef,
 ) inherits postgresql::params {
   $pg = 'postgresql::server'
 
   if $version != undef {
     warning('Passing "version" to postgresql::server is deprecated; please use postgresql::globals instead.')
     $_version = $version
   } else {
     $_version = $postgresql::params::version
   }
 
   if $createdb_path != undef{
     warning('Passing "createdb_path" to postgresql::server is deprecated, it can be removed safely for the same behaviour')
   }
 
   # Reload has its own ordering, specified by other defines
   class { "${pg}::reload": require => Class["${pg}::install"] }
 
   anchor { "${pg}::start": }->
   class { "${pg}::install": }->
   class { "${pg}::initdb": }->
   class { "${pg}::config": }->
   class { "${pg}::service": }->
   class { "${pg}::passwd": }->
   anchor { "${pg}::end": }
 }
diff --git a/manifests/server/config.pp b/manifests/server/config.pp
index a1daac8..b00a79b 100644
--- a/manifests/server/config.pp
+++ b/manifests/server/config.pp
@@ -1,185 +1,192 @@
 # PRIVATE CLASS: do not call directly
 class postgresql::server::config {
   $ip_mask_deny_postgres_user = $postgresql::server::ip_mask_deny_postgres_user
   $ip_mask_allow_all_users    = $postgresql::server::ip_mask_allow_all_users
   $listen_addresses           = $postgresql::server::listen_addresses
   $port                       = $postgresql::server::port
   $ipv4acls                   = $postgresql::server::ipv4acls
   $ipv6acls                   = $postgresql::server::ipv6acls
   $pg_hba_conf_path           = $postgresql::server::pg_hba_conf_path
   $pg_ident_conf_path         = $postgresql::server::pg_ident_conf_path
   $postgresql_conf_path       = $postgresql::server::postgresql_conf_path
   $recovery_conf_path         = $postgresql::server::recovery_conf_path
   $pg_hba_conf_defaults       = $postgresql::server::pg_hba_conf_defaults
   $user                       = $postgresql::server::user
   $group                      = $postgresql::server::group
   $version                    = $postgresql::server::_version
   $manage_pg_hba_conf         = $postgresql::server::manage_pg_hba_conf
   $manage_pg_ident_conf       = $postgresql::server::manage_pg_ident_conf
   $manage_recovery_conf       = $postgresql::server::manage_recovery_conf
   $datadir                    = $postgresql::server::datadir
   $logdir                     = $postgresql::server::logdir
   $service_name               = $postgresql::server::service_name
+  $log_line_prefix            = $postgresql::server::log_line_prefix
 
   if ($manage_pg_hba_conf == true) {
     # Prepare the main pg_hba file
     concat { $pg_hba_conf_path:
       owner  => $user,
       group  => $group,
       mode   => '0640',
       warn   => true,
       notify => Class['postgresql::server::reload'],
     }
 
     if $pg_hba_conf_defaults {
       Postgresql::Server::Pg_hba_rule {
         database => 'all',
         user => 'all',
       }
 
       # Lets setup the base rules
       $local_auth_option = $version ? {
         '8.1'   => 'sameuser',
         default => undef,
       }
       postgresql::server::pg_hba_rule { 'local access as postgres user':
         type        => 'local',
         user        => $user,
         auth_method => 'ident',
         auth_option => $local_auth_option,
         order       => '001',
       }
       postgresql::server::pg_hba_rule { 'local access to database with same name':
         type        => 'local',
         auth_method => 'ident',
         auth_option => $local_auth_option,
         order       => '002',
       }
       postgresql::server::pg_hba_rule { 'allow localhost TCP access to postgresql user':
         type        => 'host',
         user        => $user,
         address     => '127.0.0.1/32',
         auth_method => 'md5',
         order       => '003',
       }
       postgresql::server::pg_hba_rule { 'deny access to postgresql user':
         type        => 'host',
         user        => $user,
         address     => $ip_mask_deny_postgres_user,
         auth_method => 'reject',
         order       => '004',
       }
 
       postgresql::server::pg_hba_rule { 'allow access to all users':
         type        => 'host',
         address     => $ip_mask_allow_all_users,
         auth_method => 'md5',
         order       => '100',
       }
       postgresql::server::pg_hba_rule { 'allow access to ipv6 localhost':
         type        => 'host',
         address     => '::1/128',
         auth_method => 'md5',
         order       => '101',
       }
     }
 
     # ipv4acls are passed as an array of rule strings, here we transform
     # them into a resources hash, and pass the result to create_resources
     $ipv4acl_resources = postgresql_acls_to_resources_hash($ipv4acls,
     'ipv4acls', 10)
     create_resources('postgresql::server::pg_hba_rule', $ipv4acl_resources)
 
 
     # ipv6acls are passed as an array of rule strings, here we transform
     # them into a resources hash, and pass the result to create_resources
     $ipv6acl_resources = postgresql_acls_to_resources_hash($ipv6acls,
     'ipv6acls', 102)
     create_resources('postgresql::server::pg_hba_rule', $ipv6acl_resources)
   }
 
   # We must set a "listen_addresses" line in the postgresql.conf if we
   # want to allow any connections from remote hosts.
   postgresql::server::config_entry { 'listen_addresses':
     value => $listen_addresses,
   }
   postgresql::server::config_entry { 'port':
     value => $port,
   }
   postgresql::server::config_entry { 'data_directory':
     value => $datadir,
   }
   if $logdir {
     postgresql::server::config_entry { 'log_directory':
       value => $logdir,
     }
 
   }
+  # Allow timestamps in log by default
+  if $log_line_prefix {
+    postgresql::server::config_entry {'log_line_prefix':
+      value => $log_line_prefix,
+    }
+  }
 
   # RedHat-based systems hardcode some PG* variables in the init script, and need to be overriden
   # in /etc/sysconfig/pgsql/postgresql. Create a blank file so we can manage it with augeas later.
   if ($::osfamily == 'RedHat') and ($::operatingsystemrelease !~ /^7/) and ($::operatingsystem != 'Fedora') {
     file { '/etc/sysconfig/pgsql/postgresql':
       ensure  => present,
       replace => false,
     }
 
     # The init script from the packages of the postgresql.org repository
     # sources an alternate sysconfig file.
     # I. e. /etc/sysconfig/pgsql/postgresql-9.3 for PostgreSQL 9.3
     # Link to the sysconfig file set by this puppet module
     file { "/etc/sysconfig/pgsql/postgresql-${version}":
       ensure  => link,
       target  => '/etc/sysconfig/pgsql/postgresql',
       require => File[ '/etc/sysconfig/pgsql/postgresql' ],
     }
 
   }
 
 
   if ($manage_pg_ident_conf == true) {
     concat { $pg_ident_conf_path:
       owner  => $user,
       group  => $group,
       force  => true, # do not crash if there is no pg_ident_rules
       mode   => '0640',
       warn   => true,
       notify => Class['postgresql::server::reload'],
     }
   }
 
   if ($manage_recovery_conf == true) {
     concat { $recovery_conf_path:
       owner  => $user,
       group  => $group,
       force  => true, # do not crash if there is no recovery conf file
       mode   => '0640',
       warn   => true,
       notify => Class['postgresql::server::reload'],
     }
   }
 
   if $::osfamily == 'RedHat' {
     if $::operatingsystemrelease =~ /^7/ or $::operatingsystem == 'Fedora' {
       # Template uses:
       # - $::operatingsystem
       # - $service_name
       # - $port
       # - $datadir
       file { 'systemd-override':
         ensure  => present,
         path    => "/etc/systemd/system/${service_name}.service",
         owner   => root,
         group   => root,
         content => template('postgresql/systemd-override.erb'),
         notify  => [ Exec['restart-systemd'], Class['postgresql::server::service'] ],
         before  => Class['postgresql::server::reload'],
       }
       exec { 'restart-systemd':
         command     => 'systemctl daemon-reload',
         refreshonly => true,
         path        => '/bin:/usr/bin:/usr/local/bin'
       }
     }
   }
 }