Puppet: Organizing module dependencies (copy file if package is present)

In your apache class you could define a variable, that you use in a test to see if you should deliver your monitoring file or not.

class apache {
  $apacheconfigured = true;
}

class monitor {
  if $apache::apacheconfigured {
    file {'blah': ... }
  }
}

You need either virtual resources or custom facts. If the configuration of one host will change the configuration of another, then you need exported resources. I have all these things, actually. Here's a sampling.

Virtual Resources

On the Monitoring class:

@file { '/path/to/apache/monitoring/conf': 
    ensure => file,
    source => 'puppet:///modules/monitoring/apache.conf',
    tag    => 'apache-extras',
}

On the Apache class:

File <| tag == 'apache-extras' |>
Exec <| tag == 'apache-extras' |>
etc...

Custom Facts

Declare a fact like this, and put it in the appropriate place (see link above):

# apache2.rb
Facter.add("apache2") do
        setcode do
                %x{/usr/bin/test -x /etc/init.d/apache2 && /bin/echo yes || /bin/echo no}.chomp
        end
end

On the Monitoring class, use:

if $apache2 == 'yes'   {
   # include configuration for apache
}

Exported Resources

On the Apache class, included in the Apache server:

@@exec { "config-web $fqdn": 
            tag => "monitoring-server", 
    }

On the Monitoring class, included in the Monitoring server:

<<| tag == 'monitoring-server' |>>

In your extdata, create a variable that defines whether or not a server needs to be monitored. Here's an example of enabling monitoring by default and disabling it for a specific server.

extdata/common.csv

use_monitoring,true

extdata/ephemeral.example.com.csv

use_monitoring,false

In your class for each service, lookup whether monitoring is enabled. If it is, include the class responsible for monitoring that service. This could look something like

class apache {

  # Manage your apache setup here

  if extlookup("use_monitoring") == 'true' {
    include monitoring::apache
  }

}

class monitoring::apache {
  # Manage your apache monitoring setup here
}

Update: When I first read your question, I thought you were asking for a way to enable monitoring on some but not all of your Apache servers. If you want to monitor all of them, you don't even need to bother with extlookup. Just split up your monitoring class into service-specific ones and include them in the class for the service.

Why don't just require => Package['apache'] on resources in monitoring module? If there's apache and monitoring classes added to node, files that depends on apache would be installed iff it's installed succesfully. If it does not (e.g. package failed to install, or apache module is not added to node, monitoring class would just fail).

Or if you don't want it to fail, you could use something like following:

if defined(Package['apacge']) {
    file {...}
    <and so on>
}