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
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?
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.
- 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.
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.
The AppFirst Collector for Solaris currently supports both Solaris 10 and 11 running on either the Intel or SPARC architectures.
Installation of the AppFirst Collector for Solaris is accomplished with the pkgadd command:
% pkgadd -d filename
If you want to install in the current zone only, the install command is:
% sudo pkgadd -G -d filename
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:
Restart the collector to allow the changes to take effect
To start the AppFirst Collector for Solaris, run the following command:
The service can be stopped with
The service can be restarted with
The service status can be obtained with
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.
Please send any questions or concerns with this installation to your AppFirst sales team or email@example.com
Should you need to remove the AppFirst Collector for Solaris from your server, simply use the pkgrm command.
% pkgrm collector
Zones & Containers
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
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.
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
Disabling and restarting the collector in the global zone will stop the collectors in the non-global zones.
% svcadm restart appfirst
% 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.
Disabling and restarting a collector in a non-global zone will only affect that zone.
% zlogin zone-name
% sudo svcadm restart appfirst
% sudo svcadm disable appfirst
In order to remove the collector from the global zone and all non-global zones. Uninstall the collector as follows:
% pkgrm collector
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.
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
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
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.