Table of Contents
- How do I install a Collector?
- How the AppFirst Collector Works
- How is the AppFirst Collector different from a probe?
- IIS Kernel Module
- Include/Exclude Processes from Collection
- Running 32-bit Apps on 64-bit Machines
- Solaris Collector
- Zones & Containers
- Disable/Restart
- Containers
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.
Choose the appropriate collector for your operating system.
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 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.
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.
*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
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:
- 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:
- Create the Dockerfile
$ build_docker_file.sh (see github repo for command line options)
- 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.