diff --git a/manifests/config.pp b/manifests/config.pp
index 14e5ceb..a7190f6 100644
--- a/manifests/config.pp
+++ b/manifests/config.pp
@@ -1,144 +1,144 @@
 # == Class grafana::config
 #
 # This class is called from grafana
 #
 class grafana::config {
-  case $::grafana::install_method {
+  case $grafana::install_method {
     'docker': {
-      if $::grafana::container_cfg {
-        $cfg = $::grafana::cfg
+      if $grafana::container_cfg {
+        $cfg = $grafana::cfg
         $myprovision = false
 
-        file {  $::grafana::cfg_location:
+        file {  $grafana::cfg_location:
           ensure  => file,
           content => template('grafana/config.ini.erb'),
           owner   => 'grafana',
           group   => 'grafana',
         }
       }
     }
     'package','repo': {
-      $cfg = $::grafana::cfg
+      $cfg = $grafana::cfg
       $myprovision = true
 
-      file {  $::grafana::cfg_location:
+      file {  $grafana::cfg_location:
         ensure  => file,
         content => template('grafana/config.ini.erb'),
         owner   => 'grafana',
         group   => 'grafana',
       }
 
-      $sysconfig = $::grafana::sysconfig
-      $sysconfig_location = $::grafana::sysconfig_location
+      $sysconfig = $grafana::sysconfig
+      $sysconfig_location = $grafana::sysconfig_location
 
       if $sysconfig_location and $sysconfig {
         $changes = $sysconfig.map |$key, $value| { "set ${key} ${value}" }
 
         augeas{'sysconfig/grafana-server':
           context => "/files${$sysconfig_location}",
           changes => $changes,
         }
       }
 
-      file { "${::grafana::data_dir}/plugins":
+      file { "${grafana::data_dir}/plugins":
         ensure => directory,
         owner  => 'grafana',
         group  => 'grafana',
         mode   => '0750',
       }
     }
     'archive': {
-      $cfg = $::grafana::cfg
+      $cfg = $grafana::cfg
       $myprovision = true
 
-      file { "${::grafana::install_dir}/conf/custom.ini":
+      file { "${grafana::install_dir}/conf/custom.ini":
         ensure  => file,
         content => template('grafana/config.ini.erb'),
         owner   => 'grafana',
         group   => 'grafana',
       }
 
-      file { [$::grafana::data_dir, "${::grafana::data_dir}/plugins"]:
+      file { [$grafana::data_dir, "${grafana::data_dir}/plugins"]:
         ensure => directory,
         owner  => 'grafana',
         group  => 'grafana',
         mode   => '0750',
       }
     }
     default: {
-      fail("Installation method ${::grafana::install_method} not supported")
+      fail("Installation method ${grafana::install_method} not supported")
     }
   }
 
-  if $::grafana::ldap_cfg {
-    $ldap_cfg = $::grafana::ldap_cfg
+  if $grafana::ldap_cfg {
+    $ldap_cfg = $grafana::ldap_cfg
     file { '/etc/grafana/ldap.toml':
       ensure  => file,
       content => inline_template("<%= require 'toml'; TOML::Generator.new(@ldap_cfg).body %>\n"),
       owner   => 'grafana',
       group   => 'grafana',
     }
   }
 
   # If grafana version is > 5.0.0, and the install method is package,
   # repo, or archive, then use the provisioning feature. Dashboards
   # and datasources are placed in
   # /etc/grafana/provisioning/[dashboards|datasources] by default.
   # --dashboards--
   if ((versioncmp($grafana::version, '5.0.0') >= 0) and ($myprovision)) {
     $pdashboards = $grafana::provisioning_dashboards
     if (length($pdashboards) >= 1 ) {
       $dashboardpaths = flatten(grafana::deep_find_and_remove('options', $pdashboards))
       # template uses:
       #   - pdashboards
       file { $grafana::provisioning_dashboards_file:
         ensure  => file,
         owner   => 'grafana',
         group   => 'grafana',
         mode    => '0640',
         content => epp('grafana/pdashboards.yaml.epp'),
         notify  => Service[$grafana::service_name],
       }
       # Loop over all providers, extract the paths and create
       # directories for each path of dashboards.
       $dashboardpaths.each | Integer $index, Hash $options | {
         if ('path' in $options) {
           # get sub paths of 'path' and create subdirs if necessary
           $subpaths = grafana::get_sub_paths($options['path'])
           if ($grafana::create_subdirs_provisioning and (length($subpaths) >= 1)) {
             file { $subpaths :
               ensure => directory,
               before => File[$options['path']],
             }
           }
 
           file { $options['path'] :
             ensure  => directory,
             owner   => 'grafana',
             group   => 'grafana',
             mode    => '0750',
             recurse => true,
             purge   => true,
             source  => $options['puppetsource'],
           }
         }
       }
     }
 
     # --datasources--
     $pdatasources = $grafana::provisioning_datasources
     if (length($pdatasources) >= 1) {
       # template uses:
       #   - pdatasources
       file { $grafana::provisioning_datasources_file:
         ensure  => file,
         owner   => 'grafana',
         group   => 'grafana',
         mode    => '0640',
         content => epp('grafana/pdatasources.yaml.epp'),
         notify  => Service[$grafana::service_name],
       }
     }
 
   }
 }
diff --git a/manifests/init.pp b/manifests/init.pp
index a9e5cf7..ade920f 100644
--- a/manifests/init.pp
+++ b/manifests/init.pp
@@ -1,148 +1,148 @@
 # == Class: grafana
 #
 # Installs and configures Grafana.
 #
 # === Parameters
 # [*archive_source*]
 # Download location of tarball to be used with the 'archive' install method.
 # Defaults to the URL of the latest version of Grafana available at the time of module release.
 #
 # [*container_cfg*]
 # Boolean. Determines whether a configuration file should be generated when using the 'docker' install method.
 # If true, use the `cfg` and `cfg_location` parameters to control creation of the file.
 # Defaults to false.
 #
 # [*container_params*]
 # Hash of parameters to use when creating the Docker container. For use with the 'docker' install method.
 # Refer to documentation of the `docker::run` resource in the `garethr-docker` module for details of available parameters.
 # Defaults to:
 #
 #   container_params => {
 #     'image' => 'grafana/grafana:latest',
 #     'ports' => '3000'
 #   }
 #
 # [*data_dir*]
 # The directory Grafana will use for storing its data.
 # Defaults to '/var/lib/grafana'.
 #
 # [*install_dir*]
 # Installation directory to be used with the 'archive' install method.
 # Defaults to '/usr/share/grafana'.
 #
 # [*install_method*]
 # Set to 'archive' to install Grafana using the tar archive.
 # Set to 'docker' to install Grafana using the official Docker container.
 # Set to 'package' to install Grafana using .deb or .rpm packages.
 # Set to 'repo' to install Grafana using an apt or yum repository.
 # Defaults to 'package'.
 #
 # [*manage_package_repo*]
 # If true this will setup the official grafana repositories on your host. Defaults to true.
 #
 # [*package_name*]
 # The name of the package managed with the 'package' install method.
 # Defaults to 'grafana'.
 #
 # [*package_source*]
 # Download location of package to be used with the 'package' install method.
 # Defaults to the URL of the latest version of Grafana available at the time of module release.
 #
 # [*service_name*]
 # The name of the service managed with the 'archive' and 'package' install methods.
 # Defaults to 'grafana-server'.
 #
 # [*version*]
 # The version of Grafana to install and manage.
 # Defaults to 'installed'
 #
 # [*repo_name*]
 # When using 'repo' install_method, the repo to look for packages in.
 # Set to 'stable' to install only stable versions
 # Set to 'beta' to install beta versions
 # Defaults to stable.
 #
 # [*plugins*]
 # A hash of plugins to be passed to `create_resources`, wraps around the
 # `grafana_plugin` resource.
 #
 # [*provisioning_dashboards*]
 # Hash of dashboards to provision into grafana. grafana > v5.0.0
 # required. Hash will be converted into YAML and used by grafana to
 # provision dashboards.
 #
 # [*provisioning_datasources*]
 # Hash of datasources to provision into grafana, grafana > v5.0.0
 # required. Hash will be converted into YAML and used by granfana to
 # configure datasources.
 #
 # [*provisioning_dashboards_file*]
 # String with the fully qualified path to place the provisioning file
 # for dashboards, only used if provisioning_dashboards is specified.
 # Defaults to '/etc/grafana/provisioning/dashboards/puppetprovisioned.yaml'
 #
 # [*provisioning_datasources_file*]
 # String with the fully qualified path to place the provisioning file
 # for datasources, only used if provisioning_datasources is specified.
 # Default to '/etc/grafana/provisioning/datasources/puppetprovisioned.yaml'
 #
 # [*create_subdirs_provisioning*]
 # Boolean, defaults to false. If true puppet will create any
 # subdirectories in the given path when provisioning dashboards.
 #
 # [*sysconfig_location*]
 # Location of the sysconfig file for the environment of the grafana-server service.
 # This is only used when the install_method is 'package' or 'repo'.
 #
 # [*sysconfig*]
 # A hash of environment variables for the grafana-server service
 #
 # Example:
 #   sysconfig => { 'http_proxy' => 'http://proxy.example.com/' }
 #
 # === Examples
 #
 #  class { '::grafana':
 #    install_method  => 'docker',
 #  }
 #
 class grafana (
   Optional[String] $archive_source      = undef,
-  String $cfg_location                  = $::grafana::params::cfg_location,
-  Hash $cfg                             = $::grafana::params::cfg,
+  String $cfg_location                  = $grafana::params::cfg_location,
+  Hash $cfg                             = $grafana::params::cfg,
   Optional[Hash] $ldap_cfg              = undef,
-  Boolean $container_cfg                = $::grafana::params::container_cfg,
-  Hash $container_params                = $::grafana::params::container_params,
-  String $data_dir                      = $::grafana::params::data_dir,
-  String $install_dir                   = $::grafana::params::install_dir,
-  String $install_method                = $::grafana::params::install_method,
-  Boolean $manage_package_repo          = $::grafana::params::manage_package_repo,
-  String $package_name                  = $::grafana::params::package_name,
+  Boolean $container_cfg                = $grafana::params::container_cfg,
+  Hash $container_params                = $grafana::params::container_params,
+  String $data_dir                      = $grafana::params::data_dir,
+  String $install_dir                   = $grafana::params::install_dir,
+  String $install_method                = $grafana::params::install_method,
+  Boolean $manage_package_repo          = $grafana::params::manage_package_repo,
+  String $package_name                  = $grafana::params::package_name,
   Optional[String] $package_source      = undef,
-  Enum['stable', 'beta'] $repo_name     = $::grafana::params::repo_name,
-  String $rpm_iteration                 = $::grafana::params::rpm_iteration,
-  String $service_name                  = $::grafana::params::service_name,
+  Enum['stable', 'beta'] $repo_name     = $grafana::params::repo_name,
+  String $rpm_iteration                 = $grafana::params::rpm_iteration,
+  String $service_name                  = $grafana::params::service_name,
   String $version                       = 'installed',
   Hash $plugins                         = {},
   Hash $provisioning_dashboards         = {},
   Hash $provisioning_datasources        = {},
-  String $provisioning_dashboards_file  = $::grafana::params::provisioning_dashboards_file,
-  String $provisioning_datasources_file = $::grafana::params::provisioning_datasources_file,
-  Boolean $create_subdirs_provisioning  = $::grafana::params::create_subdirs_provisioning,
-  Optional[String] $sysconfig_location  = $::grafana::params::sysconfig_location,
+  String $provisioning_dashboards_file  = $grafana::params::provisioning_dashboards_file,
+  String $provisioning_datasources_file = $grafana::params::provisioning_datasources_file,
+  Boolean $create_subdirs_provisioning  = $grafana::params::create_subdirs_provisioning,
+  Optional[String] $sysconfig_location  = $grafana::params::sysconfig_location,
   Optional[Hash] $sysconfig             = undef,
 ) inherits grafana::params {
 
   contain grafana::install
   contain grafana::config
   contain grafana::service
 
   Class['grafana::install']
   -> Class['grafana::config']
   ~> Class['grafana::service']
 
   create_resources(grafana_plugin, $plugins)
   # Dependency added for Grafana_plugins to ensure it runs at the
   # correct time.
   Class['grafana::config'] -> Grafana_Plugin <| |> ~> Class['grafana::service']
 }
diff --git a/manifests/install.pp b/manifests/install.pp
index a5e5939..859742a 100644
--- a/manifests/install.pp
+++ b/manifests/install.pp
@@ -1,180 +1,180 @@
 # == Class grafana::install
 #
 class grafana::install {
   $base_url = 'https://dl.grafana.com/oss/release'
-  if $::grafana::archive_source != undef {
-    $real_archive_source = $::grafana::archive_source
+  if $grafana::archive_source != undef {
+    $real_archive_source = $grafana::archive_source
   }
   else {
-    $real_archive_source = "${base_url}/grafana-${::grafana::version}.linux-amd64.tar.gz"
+    $real_archive_source = "${base_url}/grafana-${grafana::version}.linux-amd64.tar.gz"
   }
 
-  if $::grafana::package_source != undef {
-    $real_package_source = $::grafana::package_source
+  if $grafana::package_source != undef {
+    $real_package_source = $grafana::package_source
   }
   else {
-    $real_package_source = $::osfamily ? {
-      /(RedHat|Amazon)/ => "${base_url}/grafana-${::grafana::version}-${::grafana::rpm_iteration}.x86_64.rpm",
-      'Debian'          => "${base_url}/grafana_${::grafana::version}_amd64.deb",
+    $real_package_source = $facts['os']['family'] ? {
+      /(RedHat|Amazon)/ => "${base_url}/grafana-${grafana::version}-${grafana::rpm_iteration}.x86_64.rpm",
+      'Debian'          => "${base_url}/grafana_${grafana::version}_amd64.deb",
       default           => $real_archive_source,
     }
   }
 
-  case $::grafana::install_method {
+  case $grafana::install_method {
     'docker': {
       docker::image { 'grafana/grafana':
-        image_tag => $::grafana::version,
+        image_tag => $grafana::version,
         require   => Class['docker'],
       }
     }
     'package': {
       case $facts['os']['family'] {
         'Debian': {
           package { 'libfontconfig1':
             ensure => present,
           }
 
           archive { '/tmp/grafana.deb':
             source  => $real_package_source,
           }
 
-          package { $::grafana::package_name:
+          package { $grafana::package_name:
             ensure   => present,
             provider => 'dpkg',
             source   => '/tmp/grafana.deb',
             require  => [Archive['/tmp/grafana.deb'],Package['libfontconfig1']],
           }
         }
         'RedHat': {
           package { 'fontconfig':
             ensure => present,
           }
 
-          package { $::grafana::package_name:
+          package { $grafana::package_name:
             ensure   => present,
             provider => 'rpm',
             source   => $real_package_source,
             require  => Package['fontconfig'],
           }
         }
         default: {
           fail("${facts['os']['family']} not supported")
         }
       }
     }
     'repo': {
       case $facts['os']['family'] {
         'Debian': {
           package { 'libfontconfig1':
             ensure => present,
           }
 
-          if ( $::grafana::manage_package_repo ){
+          if ( $grafana::manage_package_repo ){
             if !defined( Class['apt'] ) {
               include apt
             }
             apt::source { 'grafana':
               location     => 'https://packages.grafana.com/oss/deb',
               release      => $grafana::repo_name,
               architecture => 'amd64,arm64,armhf',
               repos        => 'main',
               key          =>  {
                 'id'     => '4E40DDF6D76E284A4A6780E48C8C34C524098CB6',
                 'source' => 'https://packages.grafana.com/gpg.key',
               },
-              before       => Package[$::grafana::package_name],
+              before       => Package[$grafana::package_name],
             }
-            Class['apt::update'] -> Package[$::grafana::package_name]
+            Class['apt::update'] -> Package[$grafana::package_name]
           }
 
-          package { $::grafana::package_name:
-            ensure  => $::grafana::version,
+          package { $grafana::package_name:
+            ensure  => $grafana::version,
             require => Package['libfontconfig1'],
           }
         }
         'RedHat': {
           package { 'fontconfig':
             ensure => present,
           }
 
-          if ( $::grafana::manage_package_repo ){
+          if ( $grafana::manage_package_repo ){
             # http://docs.grafana.org/installation/rpm/#install-via-yum-repository
             $baseurl = $grafana::repo_name ? {
               'stable' => 'https://packages.grafana.com/oss/rpm',
               'beta'   => 'https://packages.grafana.com/oss/rpm-beta',
             }
 
             yumrepo { 'grafana':
               ensure => 'absent',
-              before => Package[$::grafana::package_name],
+              before => Package[$grafana::package_name],
             }
 
             yumrepo { "grafana-${grafana::repo_name}":
               descr    => "grafana-${grafana::repo_name} repo",
               baseurl  => $baseurl,
               gpgcheck => 1,
               gpgkey   => 'https://packages.grafana.com/gpg.key',
               enabled  => 1,
-              before   => Package[$::grafana::package_name],
+              before   => Package[$grafana::package_name],
             }
           }
 
-          if $::grafana::version =~ /(installed|latest|present)/ {
-            $real_version = $::grafana::version
+          if $grafana::version =~ /(installed|latest|present)/ {
+            $real_version = $grafana::version
           } else {
-            $real_version = "${::grafana::version}-${::grafana::rpm_iteration}"
+            $real_version = "${grafana::version}-${grafana::rpm_iteration}"
           }
 
-          package { $::grafana::package_name:
+          package { $grafana::package_name:
             ensure  => $real_version,
             require => Package['fontconfig'],
           }
         }
         'Archlinux': {
-          if $::grafana::manage_package_repo {
+          if $grafana::manage_package_repo {
             fail('manage_package_repo is not supported on Archlinux')
           }
-          package { $::grafana::package_name:
+          package { $grafana::package_name:
             ensure  => 'present', # pacman provider doesn't have feature versionable
           }
         }
         default: {
-          fail("${::operatingsystem} not supported")
+          fail("${facts['os']['name']} not supported")
         }
       }
     }
     'archive': {
       # create log directory /var/log/grafana (or parameterize)
 
       if !defined(User['grafana']){
         user { 'grafana':
           ensure => present,
-          home   => $::grafana::install_dir,
+          home   => $grafana::install_dir,
         }
       }
 
-      file { $::grafana::install_dir:
+      file { $grafana::install_dir:
         ensure  => directory,
         group   => 'grafana',
         owner   => 'grafana',
         require => User['grafana'],
       }
 
       archive { '/tmp/grafana.tar.gz':
         ensure          => present,
         extract         => true,
         extract_command => 'tar xfz %s --strip-components=1',
-        extract_path    => $::grafana::install_dir,
+        extract_path    => $grafana::install_dir,
         source          => $real_archive_source,
         user            => 'grafana',
         group           => 'grafana',
         cleanup         => true,
-        require         => File[$::grafana::install_dir],
+        require         => File[$grafana::install_dir],
       }
 
     }
     default: {
-      fail("Installation method ${::grafana::install_method} not supported")
+      fail("Installation method ${grafana::install_method} not supported")
     }
   }
 }
diff --git a/manifests/service.pp b/manifests/service.pp
index 6b1b991..bcc83f5 100644
--- a/manifests/service.pp
+++ b/manifests/service.pp
@@ -1,46 +1,46 @@
 # == Class grafana::service
 #
 # This class is meant to be called from grafana
 # It ensure the service is running
 #
 class grafana::service {
-  case $::grafana::install_method {
+  case $grafana::install_method {
     'docker': {
       $container = {
-        'grafana' => $::grafana::container_params,
+        'grafana' => $grafana::container_params,
       }
 
       $defaults = {
-        image => "${::grafana::params::docker_image}:${::grafana::version}",
-        ports => $::grafana::params::docker_ports,
+        image => "${grafana::params::docker_image}:${grafana::version}",
+        ports => $grafana::params::docker_ports,
       }
 
       create_resources(docker::run, $container, $defaults)
     }
     'package','repo': {
-      service { $::grafana::service_name:
+      service { $grafana::service_name:
         ensure    => running,
         enable    => true,
-        subscribe => Package[$::grafana::package_name],
+        subscribe => Package[$grafana::package_name],
       }
     }
     'archive': {
-      $service_path   = "${::grafana::install_dir}/bin/${::grafana::service_name}"
-      $service_config = "${::grafana::install_dir}/conf/custom.ini"
+      $service_path   = "${grafana::install_dir}/bin/${grafana::service_name}"
+      $service_config = "${grafana::install_dir}/conf/custom.ini"
 
-      if !defined(Service[$::grafana::service_name]){
-        service { $::grafana::service_name:
+      if !defined(Service[$grafana::service_name]){
+        service { $grafana::service_name:
           ensure     => running,
           provider   => base,
-          binary     => "su - grafana -c '${service_path} -config=${service_config} -homepath=${::grafana::install_dir} web &'",
+          binary     => "su - grafana -c '${service_path} -config=${service_config} -homepath=${grafana::install_dir} web &'",
           hasrestart => false,
           hasstatus  => false,
-          status     => "ps -ef | grep ${::grafana::service_name} | grep -v grep",
+          status     => "ps -ef | grep ${grafana::service_name} | grep -v grep",
         }
       }
     }
     default: {
-      fail("Installation method ${::grafana::install_method} not supported")
+      fail("Installation method ${grafana::install_method} not supported")
     }
   }
 }