Collectors

Table of Contents

How do I install a Collector?

Navigate to the Administration – Collectors page and click the “Add Collector” button on the top right above the table.

1

Choose the appropriate collector for your operating system.

22-1

How the AppFirst Collector Works

The AppFirst collector situates itself between your operating system and your infrastructure. At this low-level position, it is able to collect your infrastructure’s performance by recording each call the product makes to the operating system. Our patented collector collects foundational data on your system and all processes. With this information we collect, we can correlate it along with your log data (syslog, event log), data from plugins (Nagios, JMX, and Windows Perf Counters), and operating system details.

With this data, we are able to tell you:

  • Every process’s resource utilization on every server in your environment.
  • Every thread spawned by a process.
  • Every file opened by every process on every server in your environment.
  • Every registry that has been accessed, modified, and what has been modified.
  • Every single socket connection on every server in your entire environment.
  • For every one of your sockets, we can tell you address, protocol, i/o, response time, and transaction time — all of these details about every single connection.

The collector is therefore able to record all the information you need to monitor the infrastructure’s performance without compromising your users’ private information. You can verify your security at any time by looking at a real-time sample of the raw data we’re collecting from your product (just click on the characters next to each collector, under the Sample Data column).

AppFirst Sample Collector Data

AppFirst collects up to 1600 processes at a time from your Linux servers and 500 processes at a time from your Windows servers.

Once this data has been collected, it is sent to the AppFirst servers for analysis. You can easily access the analyzed data from any computer through your account on the website. You can also control which processes are included and excluded from the collected data under the Admin tab.

The application-based (rather than server-based) focus enables the AppFirst collector to be platform-agnostic and development language-agnostic, so it will work with whatever system you may have. Worried about the collector creating overhead on your server? Unlike other performance monitoring systems, the AppFirst collector is practically invisible. Tests have demonstrated that the collector only influences the speed of your server by 1% on Windows and less than 1% on Linux.

How is the AppFirst Collector different from a probe?

AppFirst Collector

Other Agents

Situated between your product and the OS

Situated within your product

Collects information without interfering in processes

Actively polls for information from the product

1% overhead on Windows, <1% on Linux – practically invisible

Large performance overhead

Can be used during both testing and production

Impractical for usage other than testing

Can be customized to access any performance data you choose

Can only ask specific questions of the product and receive specific answers

Application-based, so the same collector can be used to monitor your entire infrastructure

You need a different agent for each component of your infrastructure

IIS Kernel Module

The Windows operating system supports the http protocol in the Kernel. AppFirst provides a Kernel Module that will collect http protocol details. It is available automatically when you install the collector.

The IIS Kernel Module intercepts network traffic directed to ports 80 (regular traffic) and 443 (secure traffic). We capture info, process, and network connection details.

Include/Exclude Processes from Collection

To include or exclude specific processes, click on the a collector on the Admin – Setup screen.

1

In the Collector Config section, you can enter a list of the processes and directories that should NOT be monitored by the collector (separated by semi-colons) in the “Excludes” box. In the “Includes” box, you can enter a list of the processes and directories that should be monitored by the Collector.

4

*Notes:

- If you add a process in the Include line, you’ll need to restart the process/service in order for our collector to pick it up.

- By default, we automatically exclude everything in C:\Windows\System32. To change this, navigate to Administration – Setup, then edit the collector you’d like.

- If a process is in both the Include and Exclude lists, the data WILL be collected by default.

For more information on configuring your collectors, click here.

Running 32-bit Apps on 64-bit Machines

Windows provides an environment where you can use 32-bit apps on 64-bit machines. The AppFirst collector for Windows 64-bit systems supports 64-bit apps and 32-bit apps with the same install.

Solaris Collector

Supported Systems

The AppFirst Collector for Solaris currently supports both Solaris 10 and 11 running on either the Intel or SPARC architectures.

Installation

Installation of the AppFirst Collector for Solaris is accomplished with the pkgadd command:

% pkgadd -d filename

where is the name of the package that was supplied by AppFirst.

If you want to install in the current zone only, the install command is:

% sudo pkgadd -G -d filename

Configuration

One configuration file must be changed to reflect your account id. To get your account id, log into appfirst.com and navigate to Administration -> Account. Take note of your account id.

Using your favorite text editor, open the file /etc/AppFirst. Alter the Tenant setting to match your account id. For example, if your account id was 1234, the Tenant setting should read:

Tenant 1234

Restart the collector to allow the changes to take effect

/etc/init.d/afcollector restart

Service Management

To start the AppFirst Collector for Solaris, run the following command:

/etc/init.d/afcollector start

The service can be stopped with

/etc/init.d/afcollector stop

The service can be restarted with

/etc/init.d/afcollector restart

The service status can be obtained with

/etc/init.d/afcollector status

If the afcollector service is running it will display the process ID of the collector process. If it is not running no output is displayed.

Getting Help

Please send any questions or concerns with this installation to your AppFirst sales team or support@appfirst.com

Removal

Should you need to remove the AppFirst Collector for Solaris from your server, simply use the pkgrm command.

% pkgrm collector

Zones & Containers

Solaris Zones

The Solaris Collector fully supports both Global and Non-Global zones.

  • Global zones are the traditional OS environment and are where the Solaris OS is installed and has visibility of all resource on the system, whether these are associated with the global zone or a non-global zone
  • Non-Global zones are zones that hosted by Global zones

Installation

The only installation required is the install of the collector package on a Solaris instance.
When installed, the global zone is functional by default. From the global zone all processes, including processes from all non-global zones, are tracked and visible. There is no indicator as to which zone a process is associated with when viewed from the global zone.

Standard Install

The standard install causes the collector to be installed in the global zone and all non-global zones.

% sudo pkgadd -d solaris-11-x86-1-0.pkg

Single or Specific Zone installation

If you want to limit the installation to a specific zone, you can install into a single zone by running the command

% sudo pkgadd -G -d solaris-11-x86-1-0.pkg

Zone specific support is enabled by starting a collector process in the non-global zone.

% zlogin zone-name

% svcadm enable collector

This will provide zone specific data for the zone zone-name.

Disable/Restart

Global Zone

Disabling and restarting the collector in the global zone will stop the collectors in the non-global zones.
Restart:

% svcadm restart appfirst

Disable:

% svcadm disable appfirst

If the collector in the global zone has been stopped or restarted it will be necessary to start the collectors in the non-global zone. In order to restart collectors in a non-global zone:

% zlogin zone-name

% sudo svcadm clear appfirst

Note that the clear command is used here instead of the restart command.

Non-Global Zone

Disabling and restarting a collector in a non-global zone will only affect that zone.

% zlogin zone-name

    Restart:

% sudo svcadm restart appfirst

    Disable:

% sudo svcadm disable appfirst

Uninstall

In order to remove the collector from the global zone and all non-global zones. Uninstall the collector as follows:

% pkgrm collector

Containers

Docker Containers

The AppFirst collector can capture details on process and application details running on the host OS or in specific Docker containers. To see the details of processes within the host OS, the AppFirst collector is installed on the host OS.

In order to capture details of applications or identify details of processes running in Docker containers, the AppFirst collector is installed in the specific container.

Installation

To install a collector on the host OS:
See collector install directions here: http://support.appfirst.com/docs/collectors/#howinstall

To install a collector in a Docker container:
There are two ways to install: download an image or create your own image. The github repository for AppFirst support for containers can be found here: https://github.com/appfirst/containers/tree/master/docker

Install by downloading an image:

  1. Download the image

    $ docker pull appfirst/containers

    NOTE: Docker supports an auto-build feature
    (http://docs.docker.com/docker-hub/builds/)
    The Docker feature allows for the use of Docker Hub’s build clusters to automatically create images from a specified Dockerfile and the AppFirst GitHub repository. The collector image will be built automatically when changes are made to the repository. Alternatively, a manual build can be accomplished with this command:

    $ curl --data "build=true" -X POST

    https://registry.hub.docker.com/u/appfirst/containers/trigger/f8e8cd66-9721-11e4-9069-0242ac110048/

Install by creating an image:

  1. Create the Dockerfile

    $ build_docker_file.sh (see github repo for command line options)

  2. Using the Dockerfile, create an image

    $ docker build -t appfirst_image .

Once you’ve installed…

Start the application in the container
Once the image has been created it’s just a matter of starting your application in the container. When built the image contains a script, startup.sh, that starts all the services, including your application, in the container. The code and documentation for the script are available in the github repository. Example start command:

$ docker run -i -t appfirst_image /startup.sh --tid=X --custom_cmd=path_to_your_application

Where X is your tenant ID and path_to_your_application is the full path of the command to start your application.