RFC 2287
Definitions of System-Level Managed Objects for Applications
Definitions of System-Level Managed Objects for Applications 🎀
Network Working Group 🌸 RFC 2287 💖 Authors: C. Krupczak (Empire Technologies, Inc.) and J. Saperia (BGS Systems Inc.) 🧚 Category: Standards Track ⭐ Date: February 1998 📅 Obsoletes / Updates: this header doesn't list any RFCs that it obsoletes or updates 🦋
Okay bestie, this is RFC 2287, and it's giving Standards Track energy 💅 It was written by C. Krupczak from Empire Technologies and J. Saperia from BGS Systems, and it's all about defining managed objects for applications at the system level. The header doesn't say it obsoletes or updates anything, so it's kind of its own main character 👑
Status of This Memo ✨
Okay so this document is an Internet standards track protocol for the Internet community, and it's asking everyone for discussion and suggestions for improvements 🫶 If you want to know where this protocol actually stands, check the current edition of the "Internet Official Protocol Standards" (STD 1). And distribution of this memo is unlimited, so share away 🌈
Copyright Notice 💜
Copyright (C) The Internet Society (1998). All Rights Reserved.Table of Contents 📚
1 Abstract .............................................. 2
2 The SNMPv2 Network Management Framework ............... 2
2.1 Object Definitions .................................. 2
3 Overview .............................................. 3
4 Architecture for Application Management ............... 3
5 The Structure of the MIB .............................. 4
5.1 System Application Installed Group .................. 5
5.2 System Application Run Group ........................ 5
5.2.1 sysApplRunTable and sysApplPastRunTable ........... 5
5.2.2 sysApplElmtRunTable and sysApplElmtPastRunTable
.................................................... 6
5.3 System Application Map Group ........................ 7
6 Definitions ........................................... 7
7 Implementation Issues ................................. 40
7.1 Implementation with Polling Agents .................. 40
7.2 sysApplElmtPastRunTable Entry Collisions ............ 40
8 Security Considerations ............................... 41
9 Acknowledgements ...................................... 42
10 Author's Address ..................................... 42
11 References ........................................... 42
12 Full Copyright Statement ............................. 441. Abstract ✨
Okay so this memo defines a chunk of the Management Information Base (MIB) for network management protocols on the Internet 🧚 It's focused on a basic set of managed objects for fault, configuration, and performance management of applications, seen from a systems perspective. The key thing is that these objects only cover info you can figure out from the system itself. You don't need any special instrumentation inside the apps to get it, which is so convenient 💖
This memo does not specify a standard for the Internet community.
2. The SNMPv2 Network Management Framework 🦋
The SNMPv2 Network Management Framework is made up of these major components:
- RFC 1902 Structure of Management Information for Version 2 of the Simple Network Management Protocol (SNMPv2) [2]
- RFC 1903 Textual Conventions for Version 2 of the Simple Network Management Protocol (SNMPv2) [3]
- RFC 1904 Conformance Statements for Version 2 of the Simple Network Management Protocol (SNMPv2) [4]
- RFC 1905 Protocol Operations for Version 2 of the Simple Network Management Protocol (SNMPv2) [5]
- RFC 1906 Transport Mappings for Version 2 of the Simple Network Management Protocol (SNMPv2) [6]
- RFC 1907 Management Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2) [7]
- RFC 1908 Coexistence between Version 1 and Version 2 of the Internet-standard Network Management Framework [8]
The Framework lets people define new objects for experimenting and testing, which is lowkey iconic 🍓
2.1. Object Definitions 🌷
Managed objects are accessed through a virtual information store called the Management Information Base, or MIB. Objects in the MIB are defined with a subset of Abstract Syntax Notation One (ASN.1) [1], and that subset comes from the Structure of Management Information (SMI) (See RFC 1902 [2]). Each object type gets named with an OBJECT IDENTIFIER, which is an administratively assigned name. The object type plus an object instance together uniquely identify one specific instantiation of the object. For human convenience, we often use a textual string, called the object descriptor, to refer to the object type 🫶
3. Overview 💅
Okay so the whole point of computing is running application software 😭 These apps are usually specialized collections of executables, files, and interprocess communications, and they exist to solve business, scientific, or other "problems." Keeping an eye on configuration, faults, performance, and control of application software across its life on a host computer is a huge deal economically 💸 For our purposes, an application is one or more units of executable code and other resources, installed on a single host system, that a manager can think of as a single object for management purposes ✨
The info in the objects of the System Application MIB supports configuration, fault, and performance management. It covers the basic attributes of application software from a systems perspective, meaning it doesn't care what each app is specifically about 🌈 It lets you describe applications as collections of executables and files that are installed and running on a host computer 🧚
This memo is mainly about defining a model for application information that lives on a host computer and can be figured out from the system itself, not from the individual applications 💜 The system-level view is meant to tell you about software that's installed and running on the host, with no need to change or add code to the applications themselves 🎀 The team went this route to make implementation easier and faster, while still leaving room for future growth 🦋
4. Architecture for Application Management 🌸
Okay bestie, it's fully expected that more MIB modules will be defined over time to give even more detail about applications 🧚 This MIB module is the most general case: a set of management objects that provides generic info about applications, with values that can be determined from the computer system itself and don't need any instrumentation inside the application 💖
A finer-grained level of detail is planned for the future "appl MIB," which will be a common set of management objects for generic applications. That one does need some kind of instrumentation in the application to get its values 🔥 Since the applmib MIB module will be more detailed, any connection to the sysAppl MIB should be made by having references from the detailed appl MIB back to the more generic sysAppl MIB 🫶 In the same way, as application-specific MIB modules like the WWW MIB get developed over time, those more specific MIBs should reference back to the more generic ones 👑
This MIB module doesn't try to capture every detailed piece of info for managing applications. What it does give you is a basic systems-level view of the applications and their components on a single host system 🍓
5. The Structure of the MIB 🌈
The System Application MIB models application packages as a whole, and it also models the individual elements (files and executables) that together form an application ✨ It's set up to model info about installed application packages and the elements that make up each package 💅 The MIB also models activity info for applications (and their components) that are running or have run on the host system before 🧚 By modeling applications and their elements this way, the MIB gives you the link you need to tie executing processes to the applications they belong to 💖
The objects are arranged into these groups:
- System Application Installed Group
- sysApplInstallPkgTable
- sysApplInstallElmtTable
- System Application Run Group
- sysApplRunTable
- sysApplPastRunTable
- sysApplElmtRunTable
- sysApplElmtPastRunTable
- (scalars for restricting table sizes)
- System Application Map Group
- sysApplMapTable
You can see from the arrangement above that, in each category, the MIB first treats an application package as a whole, and then breaks the package down to give info about each of its elements (executable and non-executable files) 🦋
5.1. System Application Installed Group 🌷
The System Application Installed group has two tables, and they're how admins figure out which applications are installed on a system and what their parts are 🫶 The first one, sysApplInstallPkgTable, lists the application packages installed on a particular host. The second, sysApplInstallElmtTable, has info about the executables and non-executable files (the "elements") that together make up an application 💜
NOTE: This MIB is meant to work with applications that have been installed on a particular host. "Installed" here means the application's existence, and the link between an application and its component files, can be discovered without any extra instrumentation of the application itself. This may require certain conventions, like using a central software installation mechanism or registry when installing application packages. For example, many UNIX systems use a "pkgadd" utility to track installed packages, while many PC systems use a global registry 🙈
5.2. System Application Run Group 🎀
Okay so this group models activity info for applications that have been invoked and are either running right now or ran earlier on the host system 🔥 The individual elements of an invoked application are modeled too, so you can see which processes are running and which ones ran in the past ✨ All of this is handled by two pairs of tables: one pair for currently running applications and past-run applications, and another pair for currently running elements and past-run elements. There are also seven scalars that control the size of the past-run tables 🧚💖
5.2.1. sysApplRunTable and sysApplPastRunTable ✨
okay so the sysApplRunTable and sysApplPastRunTable are the first tag team 👯♀️. The sysApplRunTable holds the application instances that are running on the host right now. Every time an app gets invoked, a brand new entry shows up in the sysApplRunTable to track that one specific invocation 🎀. That entry sticks around until the instance terminates, and then it gets deleted from the sysApplRunTable and moved over to the sysApplPastRunTable 🦋
The sysApplPastRunTable is the history queen 👑. It keeps a record of app instances that already ran on the host. An entry gets added here when an invoked application from the sysApplRunTable terminates. So the entry gets removed from the sysApplRunTable and a matching one gets added to the sysApplPastRunTable. Easy peasy 💖
Now, the sysApplPastRunTable is going to keep growing forever as stuff runs and ends, which is kind of a lot 😭 So there are two scalars that handle the aging-out of entries 🧹 sysApplPastRunMaxRows is the max number of entries the table can hold, and sysApplPastRunTblTimeLimit is the max age of those entries. The oldest entries get removed first. Lowkey iconic behaviour 💅
Also, these two tables track each INVOCATION of an application, not just the app itself 🌸 One application package can get invoked multiple times, and each of those invocations gets its own entry in the sysApplRunTable. Every single one gets recorded separately. Main character energy for every run 🎬
Here's the tricky part 🙈 To implement this group, the agent has to be able to notice that an application was invoked, and also figure out when that invocation ends. This is honestly a complex problem, because one application invocation can involve a bunch of processes. Some of them need to stay running the whole time, and others might come and go. That's where the sysApplInstallElmtRole columnar object in the sysApplInstallElmtTable comes in 🧚 It helps by saying which element is the application's primary executable, which elements have to be running for the application to be running, which elements depend on required elements, and so on. Check the description of sysApplInstallElmtRole for more details 🔍
5.2.2. sysApplElmtRunTable and sysApplElmtPastRunTable 🦋
So the sysApplRunTable and sysApplPastRunTable look at applications as a whole. The sysApplElmtRunTable and sysApplElmtPastRunTable zoom in on the application's executable elements (processes) 🔎 They tell you which ones are running right now or ran in the past.
The sysApplElmtRunTable has an entry for every process that's currently running on the host 💜 A new entry gets created when a process starts, and it stays until that process terminates. Here's the twist: to give you the full picture of the system's load, this table lists EVERY running process, not just the ones that belong to an identified application 🌈 But when processes terminate, only entries for elements of an identified application get moved to the sysApplElmtPastRunTable.
The sysApplElmtPastRunTable keeps a history of processes that ran on the host as part of an application 📜 When a process in the sysApplElmtRunTable terminates, its entry moves over here, but only if that process was part of an identified application. If a process can't be linked to any 'parent' application, it just gets removed from the sysApplElmtRunTable and that's it. This is why stuff like 'ps' or 'grep' can show up in the sysApplElmtRunTable (they're eating resources, so they're "interesting" 👀) without ever landing in the sysApplElmtPastRunTable 🙈
This table will also keep growing as processes run and end, so two scalars handle the aging-out here too ⏳ sysApplElmtPastRunMaxRows is the max number of entries the table can contain, and sysApplElmtPastRunTblTimeLimit is the max age of the entries. Oldest entries get removed first 🫶
5.3. System Application Map Group 🗺️
The System Application Map group has one table, the sysApplMapTable 🧭 Its whole job is to give you a backwards mapping. Given a known process identification number, it helps you figure out the invoked application, the installed element, and the installed application package 🎯
6. Definitions 💅
SYSAPPL-MIB DEFINITIONS ::= BEGIN
IMPORTS
MODULE-IDENTITY, OBJECT-TYPE,
Unsigned32, TimeTicks, Counter32, Gauge32
FROM SNMPv2-SMI
DateAndTime, TEXTUAL-CONVENTION
FROM SNMPv2-TC
MODULE-COMPLIANCE, OBJECT-GROUP
FROM SNMPv2-CONF
mib-2 FROM SNMPv2-SMI;
-- System Application MIB
sysApplMIB MODULE-IDENTITY
LAST-UPDATED "9710200000Z"
ORGANIZATION "IETF Applications MIB Working Group"
CONTACT-INFO
"Cheryl Krupczak (Editor, WG Advisor)
Postal: Empire Technologies, Inc.
541 Tenth Street NW
Suite 169
Atlanta, GA 30318
USA
Phone: (770) 384-0184
Email: cheryl@empiretech.com
Jon Saperia (WG Chair)
Postal: BGS Systems, Inc.
One First Avenue
Waltham, MA 02254-9111
USA
Phone: (617) 891-0000
Email: saperia@networks.bgs.com"
DESCRIPTION
"The MIB module defines management objects that model
applications as collections of executables and files
installed and executing on a host system. The MIB
presents a system-level view of applications; i.e.,
objects in this MIB are limited to those attributes
that can typically be obtained from the system itself
without adding special instrumentation to the applications."
::= { mib-2 54 }
sysApplOBJ OBJECT IDENTIFIER ::= { sysApplMIB 1 }
sysApplInstalled OBJECT IDENTIFIER ::= { sysApplOBJ 1 }
sysApplRun OBJECT IDENTIFIER ::= { sysApplOBJ 2 }
sysApplMap OBJECT IDENTIFIER ::= { sysApplOBJ 3 }
sysApplNotifications OBJECT IDENTIFIER ::= { sysApplMIB 2 }
sysApplConformance OBJECT IDENTIFIER ::= { sysApplMIB 3 }
-- Textual Conventions
RunState ::= TEXTUAL-CONVENTION
STATUS current
DESCRIPTION
"This TC describes the current execution state of
a running application or process. The possible
values are:
running(1),
runnable(2), - waiting for a resource (CPU, etc.)
waiting(3), - waiting for an event
exiting(4),
other(5) - other invalid state"
SYNTAX INTEGER {
running (1),
runnable (2), -- waiting for resource (CPU, etc.)
waiting (3), -- waiting for event
exiting (4),
other (5) -- other invalid state
}
LongUtf8String ::= TEXTUAL-CONVENTION
DISPLAY-HINT "1024a"
STATUS current
DESCRIPTION
"To facilitate internationalization, this TC
represents information taken from the ISO/IEC IS
10646-1 character set, encoded as an octet string
using the UTF-8 character encoding scheme described
in RFC 2044 [10]. For strings in 7-bit US-ASCII,
there is no impact since the UTF-8 representation
is identical to the US-ASCII encoding."
SYNTAX OCTET STRING (SIZE (0..1024))
Utf8String ::= TEXTUAL-CONVENTION
DISPLAY-HINT "255a"
STATUS current
DESCRIPTION
"To facilitate internationalization, this TC
represents information taken from the ISO/IEC IS
10646-1 character set, encoded as an octet string
using the UTF-8 character encoding scheme described
in RFC 2044 [10]. For strings in 7-bit US-ASCII,
there is no impact since the UTF-8 representation
is identical to the US-ASCII encoding."
SYNTAX OCTET STRING (SIZE (0..255))
-- sysApplInstalled Group
-- This group provides information about application packages
-- that have been installed on the host computer. The group
-- contains two tables. The first, the sysApplInstallPkgTable,
-- describes the application packages, the second, the
-- sysApplInstallElmtTable, describes the constituent elements
-- (files and executables) which compose an application package.
--
-- In order to appear in this group, an application and its
-- component files must be discoverable by the system itself,
-- possibly through some type of software installation mechanism
-- or registry.
-- sysApplInstallPkgTable
-- The system installed application packages table provides
-- information on the software packages installed on a system.
-- These packages may consist of many different files including
-- executable and non-executable files.
sysApplInstallPkgTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplInstallPkgEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The table listing the software application packages
installed on a host computer. In order to appear in
this table, it may be necessary for the application
to be installed using some type of software
installation mechanism or global registry so that its
existence can be detected by the agent implementation."
::= { sysApplInstalled 1 }
sysApplInstallPkgEntry OBJECT-TYPE
SYNTAX SysApplInstallPkgEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The logical row describing an installed application
package."
INDEX { sysApplInstallPkgIndex }
::= { sysApplInstallPkgTable 1 }
SysApplInstallPkgEntry ::= SEQUENCE {
sysApplInstallPkgIndex Unsigned32,
sysApplInstallPkgManufacturer Utf8String,
sysApplInstallPkgProductName Utf8String,
sysApplInstallPkgVersion Utf8String,
sysApplInstallPkgSerialNumber Utf8String,
sysApplInstallPkgDate DateAndTime,
sysApplInstallPkgLocation LongUtf8String
}
sysApplInstallPkgIndex OBJECT-TYPE
SYNTAX Unsigned32 (1..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An integer used only for indexing purposes.
Generally monotonically increasing from 1 as new
applications are installed.
The value for each installed application must
remain constant at least from one re-initialization of
the network management entity which implements this
MIB module to the next re-initialization.
The specific value is meaningful only within a given SNMP
entity. A sysApplInstallPkgIndex value must not be re-used
until the next agent entity restart in the event the
installed application entry is deleted."
::= { sysApplInstallPkgEntry 1 }Okay bestie, we're picking right back up in the object definitions 💅 Here's the manufacturer, product name, version, and serial number stuff for installed packages, and they're all read-only, so the agent is just reporting what's there 🎀
sysApplInstallPkgManufacturer OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The Manufacturer of the software application package."
::= { sysApplInstallPkgEntry 2 }
sysApplInstallPkgProductName OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The name assigned to the software application package
by the Manufacturer."
::= { sysApplInstallPkgEntry 3 }
sysApplInstallPkgVersion OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The version number assigned to the application package
by the manufacturer of the software."
::= { sysApplInstallPkgEntry 4 }
sysApplInstallPkgSerialNumber OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The serial number of the software assigned by the
manufacturer."
::= { sysApplInstallPkgEntry 5 }Next up is the install date 📅 It's a DateAndTime value that records when the app landed on the host. Then the install location, which is a LongUtf8String holding the full path where the package lives. The example is giving very clear vibes 🧚
sysApplInstallPkgDate OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The date and time this software application was installed
on the host."
::= { sysApplInstallPkgEntry 6 }
sysApplInstallPkgLocation OBJECT-TYPE
SYNTAX LongUtf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The complete path name where the application package
is installed. For example, the value would be
'/opt/MyapplDir' if the application package was installed
in the /opt/MyapplDir directory."
::= { sysApplInstallPkgEntry 7 }Now we get to sysApplInstallElmtTable 🦋 This is the table of the individual files and executables inside each package. Every row points back to its parent package through the index, so one package can have lots of element rows. The table is indexed by sysApplInstallPkgIndex and sysApplInstallElmtIndex, which makes it easy to grab all the elements for one particular package. So organised, I'm obsessed 😭
-- sysApplInstallElmtTable
-- The table describing the individual application package
-- elements (files and executables) installed on the host computer.
sysApplInstallElmtTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplInstallElmtEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"This table details the individual application package
elements (files and executables) which comprise the
applications defined in the sysApplInstallPkg Table.
Each entry in this table has an index to the
sysApplInstallPkg table to identify the application
package of which it is a part. As a result, there may
be many entries in this table for each instance in the
sysApplInstallPkg Table.
Table entries are indexed by sysApplInstallPkgIndex,
sysApplInstallElmtIndex to facilitate retrieval of
all elements associated with a particular installed
application package."
::= { sysApplInstalled 2 }
sysApplInstallElmtEntry OBJECT-TYPE
SYNTAX SysApplInstallElmtEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The logical row describing an element of an installed
application. The element may be an executable or
non-executable file."
INDEX {sysApplInstallPkgIndex, sysApplInstallElmtIndex}
::= { sysApplInstallElmtTable 1 }
SysApplInstallElmtEntry ::= SEQUENCE {
sysApplInstallElmtIndex Unsigned32,
sysApplInstallElmtName Utf8String,
sysApplInstallElmtType INTEGER,
sysApplInstallElmtDate DateAndTime,
sysApplInstallElmtPath LongUtf8String,
sysApplInstallElmtSizeHigh Unsigned32,
sysApplInstallElmtSizeLow Unsigned32,
sysApplInstallElmtRole BITS,
sysApplInstallElmtModifyDate DateAndTime,
sysApplInstallElmtCurSizeHigh Unsigned32,
sysApplInstallElmtCurSizeLow Unsigned32
}The element index is the row key 🔑 It's an arbitrary integer, and it stays unique across every row that exists or has existed since the last agent restart. Then the element name is just a Utf8String that says what the element is called inside the app 🌸
sysApplInstallElmtIndex OBJECT-TYPE
SYNTAX Unsigned32 (1..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"An arbitrary integer used for indexing. The value
of this index is unique among all rows in this table
that exist or have existed since the last agent restart."
::= { sysApplInstallElmtEntry 1 }
sysApplInstallElmtName OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The name of this element which is contained in the
application."
::= { sysApplInstallElmtEntry 2 }The element type is an enumerated INTEGER 🍓 It can be unknown, nonexecutable, or one of three executable kinds: operating system, device driver, or application. Those last three are the executables, so bestie, that's the whole breakdown.
sysApplInstallElmtType OBJECT-TYPE
SYNTAX INTEGER {
unknown(1),
nonexecutable(2),
operatingSystem(3), -- executable
deviceDriver(4), -- executable
application(5) -- executable
}
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The type of element that is part of the installed
application."
::= { sysApplInstallElmtEntry 3 }
sysApplInstallElmtDate OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The date and time that this component was installed on
the system."
::= { sysApplInstallElmtEntry 4 }The element path is where things get really thorough 🗺️ It's the full directory path, and the spec explains how the agent figures it out. Most packages list their elements, and elements usually sit in subdirectories under the package folder. If none of that info exists, the agent can search those subdirectories, and if it still can't find the element, the path is unknown and null gets returned. Lowkey iconic detective work 🕵️♀️
sysApplInstallElmtPath OBJECT-TYPE
SYNTAX LongUtf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The full directory path where this element is installed.
For example, the value would be '/opt/EMPuma/bin' for an
element installed in the directory '/opt/EMPuma/bin'.
Most application packages include information about the
elements contained in the package. In addition, elements
are typically installed in sub-directories under the
package installation directory. In cases where the
element path names are not included in the package
information itself, the path can usually be determined
by a simple search of the sub-directories. If the
element is not installed in that location and there is
no other information available to the agent implementation,
then the path is unknown and null is returned."
::= { sysApplInstallElmtEntry 5}Size time! 📦 The file size gets split into two counters, a high part counted in 2^32 byte blocks and a low part holding the size modulo 2^32. Together they give you the full size of the file on disk right after install. The examples are a perfect little math lesson 🧮
sysApplInstallElmtSizeHigh OBJECT-TYPE
SYNTAX Unsigned32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The installed file size in 2^32 byte blocks. This is
the size of the file on disk immediately after installation.
For example, for a file with a total size of 4,294,967,296
bytes, this variable would have a value of 1; for a file
with a total size of 4,294,967,295 bytes this variable
would be 0."
::= { sysApplInstallElmtEntry 6 }
sysApplInstallElmtSizeLow OBJECT-TYPE
SYNTAX Unsigned32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The installed file size modulo 2^32 bytes. This is
the size of the file on disk immediately after installation.
For example, for a file with a total size of 4,294,967,296
bytes this variable would have a value of 0; for a file with
a total size of 4,294,967,295 bytes this variable would be
4,294,967,295."
::= { sysApplInstallElmtEntry 7 }Heads up, this next one is the role object, and it's aBITSvalue you can set, so it's the main thing that decides how the agent reads an app's status 🚨 The default isunknown(5), and once that's set the other bits don't mean anything.
sysApplInstallElmtRole OBJECT-TYPE
SYNTAX BITS {
executable(0),
-- An application may have one or
-- more executable elements. The rest of the
-- bits have no meaning if the element is not
-- executable.
exclusive(1),
-- Only one copy of an exclusive element may be
-- running per invocation of the running
-- application.
primary(2),
-- The primary executable. An application can
-- have one, and only one element that is designated
-- as the primary executable. The execution of
-- this element constitutes an invocation of
-- the application. This is used by the agent
-- implementation to determine the initiation of
-- an application. The primary executable must
-- remain running long enough for the agent
-- implementation to detect its presence.
required(3),
-- An application may have zero or more required
-- elements. All required elements must be running
-- in order for the application to be judged to be
-- running and healthy.
dependent(4),
-- An application may have zero or more
-- dependent elements. Dependent elements may
-- not be running unless required elements are.
unknown(5)
-- Default value for the case when an operator
-- has not yet assigned one of the other values.
-- When set, bits 1, 2, 3, and 4 have no meaning.
}
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"An operator assigned value used in the determination of
application status. This value is used by the agent to
determine both the mapping of started processes to the
initiation of an application, as well as to allow for a
determination of application health. The default value,
unknown(5), is used when an operator has not yet assigned
one of the other values. If unknown(5) is set, bits
1 - 4 have no meaning. The possible values are:
executable(0),
An application may have one or
more executable elements. The rest of the
bits have no meaning if the element is not
executable.
exclusive(1),
Only one copy of an exclusive element may be
running per invocation of the running
application.
primary(2),
The primary executable. An application can
have one, and only one element that is designated
as the primary executable. The execution of
this element constitutes an invocation of
the application. This is used by the agent
implementation to determine the initiation of
an application. The primary executable must
remain running long enough for the agent
implementation to detect its presence.
required(3),
An application may have zero or more required
elements. All required elements must be running
in order for the application to be judged to be
running and healthy.
dependent(4),Okay so the install table's role column is still going, and it's giving detail 🎀
An application may have zero or more
dependent elements. Dependent elements may
not be running unless required elements are.
unknown(5)
Default value for the case when an operator
has not yet assigned one of the other values.
When set, bits 1, 2, 3, and 4 have no meaning.
sysApplInstallElmtRole is used by the agent implementation
in determining the initiation of an application, the
current state of a running application (see
sysApplRunCurrentState), when an application invocation is
no longer running, and the exit status of a terminated
application invocation (see sysApplPastRunExitState)."
DEFVAL { { unknown } }
::= { sysApplInstallElmtEntry 8 }
sysApplInstallElmtModifyDate OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The date and time that this element was last modified.
Modification of the sysApplInstallElmtRole columnar
object does NOT constitute a modification of the element
itself and should not affect the value of this object."
::= { sysApplInstallElmtEntry 9 }
sysApplInstallElmtCurSizeHigh OBJECT-TYPE
SYNTAX Unsigned32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The current file size in 2^32 byte blocks.
For example, for a file with a total size of 4,294,967,296
bytes, this variable would have a value of 1; for a file
with a total size of 4,294,967,295 bytes this variable
would be 0."
::= { sysApplInstallElmtEntry 10 }
sysApplInstallElmtCurSizeLow OBJECT-TYPE
SYNTAX Unsigned32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The current file size modulo 2^32 bytes.
For example, for a file with a total size of 4,294,967,296
bytes this variable would have a value of 0; for a file with
a total size of 4,294,967,295 bytes this variable would be
4,294,967,295."
::= { sysApplInstallElmtEntry 11 }Next up is the run group, and it's the main character of this whole MIB ✨ It tracks apps that are running right now and apps that already ran, and the individual elements inside each app get the same treatment 💅
-- sysApplRun Group
-- This group models activity information for applications
-- that have been invoked and are either currently running,
-- or have previously run on the host system. Likewise,
-- the individual elements of an invoked application are
-- also modeled to show currently running processes, and
-- processes that have run in the past.
-- sysApplRunTable
-- The sysApplRunTable contains the application instances
-- which are currently running on the host. Since a single
-- application might be invoked multiple times, an entry is
-- added to this table for each INVOCATION of an application.
-- The table is indexed by sysApplInstallPkgIndex, sysApplRunIndex
-- to enable managers to easily locate all invocations of
-- a particular application package.
sysApplRunTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The table describes the applications which are executing
on the host. Each time an application is invoked,
an entry is created in this table. When an application ends,
the entry is removed from this table and a corresponding
entry is created in the SysApplPastRunTable.
A new entry is created in this table whenever the agent
implementation detects a new running process that is an
installed application element whose sysApplInstallElmtRole
designates it as being the application's primary executable
(sysApplInstallElmtRole = primary(2) ).
The table is indexed by sysApplInstallPkgIndex,
sysApplRunIndex to enable managers to easily locate all
invocations of a particular application package."
::= { sysApplRun 1 }
sysApplRunEntry OBJECT-TYPE
SYNTAX SysApplRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The logical row describing an application which is
currently running on this host."
INDEX { sysApplInstallPkgIndex, sysApplRunIndex }
::= { sysApplRunTable 1 }
SysApplRunEntry ::= SEQUENCE {
sysApplRunIndex Unsigned32,
sysApplRunStarted DateAndTime,
sysApplRunCurrentState RunState
}
sysApplRunIndex OBJECT-TYPE
SYNTAX Unsigned32 (1..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table. An arbitrary
integer used only for indexing purposes. Generally
monotonically increasing from 1 as new applications are
started on the host, it uniquely identifies application
invocations.
The numbering for this index increases by 1 for each
INVOCATION of an application, regardless of which
installed application package this entry represents a
running instance of.
An example of the indexing for a couple of entries is
shown below.
:
sysApplRunStarted.17.14
sysApplRunStarted.17.63
sysApplRunStarted.18.13
:
In this example, the agent has observed 12 application
invocations when the application represented by entry 18
in the sysApplInstallPkgTable is invoked. The next
invocation detected by the agent is an invocation of
installed application package 17. Some time later,
installed application 17 is invoked a second time.
NOTE: this index is not intended to reflect a real-time
(wall clock time) ordering of application invocations;
it is merely intended to uniquely identify running
instances of applications. Although the
sysApplInstallPkgIndex is included in the INDEX clause
for this table, it serves only to ease searching of
this table by installed application and does not
contribute to uniquely identifying table entries."
::= { sysApplRunEntry 1 }
sysApplRunStarted OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The date and time that the application was started."
::= { sysApplRunEntry 2 }
sysApplRunCurrentState OBJECT-TYPE
SYNTAX RunState
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The current state of the running application instance.
The possible values are running(1), runnable(2) but waiting
for a resource such as CPU, waiting(3) for an event,
exiting(4), or other(5). This value is based on an evaluation
of the running elements of this application instance (see
sysApplElmRunState) and their Roles as defined by
sysApplInstallElmtRole. An agent implementation may
detect that an application instance is in the process of
exiting if one or more of its REQUIRED elements are no
longer running. Most agent implementations will wait until
a second internal poll has been completed to give the
system time to start REQUIRED elements before marking the
application instance as exiting."
::= { sysApplRunEntry 3 }Now the past run table, which is basically the app's diary of everything that already happened 📖🦋
-- sysApplPastRunTable
-- The sysApplPastRunTable provides a history of applications
-- previously run on the host computer. Entries are removed from
-- the sysApplRunTable and corresponding entries are added to this
-- table when an application becomes inactive. Entries remain in
-- this table until they are aged out when either the table size
-- reaches a maximum as determined by the sysApplPastRunMaxRows,
-- or when an entry has aged to exceed a time limit as set be
-- sysApplPastRunTblTimeLimit.
--
-- When aging out entries, the oldest entry, as determined by
-- the value of sysApplPastRunTimeEnded, will be removed first.
sysApplPastRunTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplPastRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A history of the applications that have previously run
on the host computer. An entry's information is moved to
this table from the sysApplRunTable when the invoked
application represented by the entry ceases to be running.
An agent implementation can determine that an application
invocation is no longer running by evaluating the running
elements of the application instance and their Roles as
defined by sysApplInstallElmtRole. Obviously, if there
are no running elements for the application instance,
then the application invocation is no longer running.
If any one of the REQUIRED elements is not running,
the application instance may be in the process of exiting.
Most agent implementations will wait until a second internal
poll has been completed to give the system time to either
restart partial failures or to give all elements time to
exit. If, after the second poll, there are REQUIRED
elements that are not running, then the application
instance may be considered by the agent implementation
to no longer be running.
Entries remain in the sysApplPastRunTable until they
are aged out when either the table size reaches a maximum
as determined by the sysApplPastRunMaxRows, or when an entry
has aged to exceed a time limit as set by
sysApplPastRunTblTimeLimit.
Entries in this table are indexed by sysApplInstallPkgIndex,
sysApplPastRunIndex to facilitate retrieval of all past
run invocations of a particular installed application."
::= { sysApplRun 2 }
sysApplPastRunEntry OBJECT-TYPE
SYNTAX SysApplPastRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The logical row describing an invocation of an application
which was previously run and has terminated. The entry
is basically copied from the sysApplRunTable when the
application instance terminates. Hence, the entry's
value for sysApplPastRunIndex is the same as its value was
for sysApplRunIndex."
INDEX { sysApplInstallPkgIndex, sysApplPastRunIndex }
::= { sysApplPastRunTable 1 }
SysApplPastRunEntry ::= SEQUENCE {
sysApplPastRunIndex Unsigned32,
sysApplPastRunStarted DateAndTime,
sysApplPastRunExitState INTEGER,
sysApplPastRunTimeEnded DateAndTime
}
sysApplPastRunIndex OBJECT-TYPE
SYNTAX Unsigned32 (1..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table. An integer
matching the value of the removed sysApplRunIndex
corresponding to this row."
::= { sysApplPastRunEntry 1 }
sysApplPastRunStarted OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The date and time that the application was started."
::= { sysApplPastRunEntry 2 }That's the end of this part, and the next part picks up right after the sysApplPastRunStarted entry 💖✨
Okay bestie, the exit state is giving full drama 😭💅
sysApplPastRunExitState OBJECT-TYPE
SYNTAX INTEGER {
complete (1), -- normal exit at sysApplRunTimeEnded
failed (2), -- abnormal exit
other (3)
}
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The state of the application instance when it terminated.
This value is based on an evaluation of the running elements
of an application and their Roles as defined by
sysApplInstallElmtRole. An application instance is said to
have exited in a COMPLETE state and its entry is removed
from the sysApplRunTable and added to the sysApplPastRunTable
when the agent detects that ALL elements of an application
invocation are no longer running. Most agent implementations
will wait until a second internal poll has been completed to
give the system time to either restart partial failures or
to give all elements time to exit. A failed state occurs if,
after the second poll, any elements continue to run but
one or more of the REQUIRED elements are no longer running.
All other combinations MUST be defined as OTHER."
::= { sysApplPastRunEntry 3 }
sysApplPastRunTimeEnded OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The DateAndTime the application instance was determined
to be no longer running."
::= { sysApplPastRunEntry 4 }Next up is the sysApplElmtRunTable, the process roster. It's basically a guest list for every process on the host, and it is SO organized 🎀✨
-- sysApplElmtRunTable
-- The sysApplElmtRunTable contains an entry for each process that
-- is currently running on the host. An entry is created in
-- this table for each process at the time it is started, and will
-- remain in the table until the process terminates.
--
-- The table is indexed by sysApplElmtRunInstallPkg,
-- sysApplElmtRunInvocID, and sysApplElmtRunIndex to make it easy
-- to locate all running elements of a particular invoked application
-- which has been installed on the system.
sysApplElmtRunTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplElmtRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The table describes the processes which are
currently executing on the host system. Each entry
represents a running process and is associated with
the invoked application of which that process is a part, if
possible. This table contains an entry for every process
currently running on the system, regardless of whether its
'parent' application can be determined. So, for example,
processes like 'ps' and 'grep' will have entries though they
are not associated with an installed application package.
Because a running application may involve
more than one executable, it is possible to have
multiple entries in this table for each application.
Entries are removed from this table when the process
terminates.
The table is indexed by sysApplElmtRunInstallPkg,
sysApplElmtRunInvocID, and sysApplElmtRunIndex to
facilitate the retrieval of all running elements of a
particular invoked application which has been installed on
the system."
::= { sysApplRun 3 }
sysApplElmtRunEntry OBJECT-TYPE
SYNTAX SysApplElmtRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The logical row describing a process currently
running on this host. When possible, the entry is
associated with the invoked application of which it
is a part."
INDEX { sysApplElmtRunInstallPkg, sysApplElmtRunInvocID,
sysApplElmtRunIndex }
::= { sysApplElmtRunTable 1 }
SysApplElmtRunEntry ::= SEQUENCE {
sysApplElmtRunInstallPkg Unsigned32,
sysApplElmtRunInvocID Unsigned32,
sysApplElmtRunIndex Unsigned32,
sysApplElmtRunInstallID Unsigned32,
sysApplElmtRunTimeStarted DateAndTime,
sysApplElmtRunState RunState,
sysApplElmtRunName LongUtf8String,
sysApplElmtRunParameters Utf8String,
sysApplElmtRunCPU TimeTicks,
sysApplElmtRunMemory Gauge32,
sysApplElmtRunNumFiles Gauge32,
sysApplElmtRunUser Utf8String
}
sysApplElmtRunInstallPkg OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table, this value
identifies the installed software package for
the application of which this process is a part.
Provided that the process's 'parent' application can be
determined, the value of this object is the same
value as the sysApplInstallPkgIndex for the
entry in the sysApplInstallPkgTable that corresponds
to the installed application of which this process
is a part.
If, however, the 'parent' application cannot be
determined, (for example the process is not part
of a particular installed application), the value
for this object is then '0', signifying that this
process cannot be related back to an application,
and in turn, an installed software package."
::= { sysApplElmtRunEntry 1 }
sysApplElmtRunInvocID OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table, this value
identifies the invocation of an application of which
this process is a part. Provided that the 'parent'
application can be determined, the value of this object
is the same value as the sysApplRunIndex for the
corresponding application invocation in the
sysApplRunTable.
If, however, the 'parent' application cannot be
determined, the value for this object is then '0',
signifying that this process cannot be related back
to an invocation of an application in the
sysApplRunTable."
::= { sysApplElmtRunEntry 2 }
sysApplElmtRunIndex OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table. A unique value
for each process running on the host. Wherever
possible, this should be the system's native, unique
identification number."
::= { sysApplElmtRunEntry 3 }
sysApplElmtRunInstallID OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The index into the sysApplInstallElmtTable. The
value of this object is the same value as the
sysApplInstallElmtIndex for the application element
of which this entry represents a running instance.
If this process cannot be associated with an installed
executable, the value should be '0'."
::= { sysApplElmtRunEntry 4 }
sysApplElmtRunTimeStarted OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The time the process was started."
::= { sysApplElmtRunEntry 5 }
sysApplElmtRunState OBJECT-TYPE
SYNTAX RunState
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The current state of the running process. The
possible values are running(1), runnable(2) but waiting
for a resource such as CPU, waiting(3) for an event,
exiting(4), or other(5)."
::= { sysApplElmtRunEntry 6 }
sysApplElmtRunName OBJECT-TYPE
SYNTAX LongUtf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The full path and filename of the process.
For example, '/opt/MYYpkg/bin/myyproc' would
be returned for process 'myyproc' whose execution
path is '/opt/MYYpkg/bin/myyproc'."
::= { sysApplElmtRunEntry 7 }
sysApplElmtRunParameters OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The starting parameters for the process."
::= { sysApplElmtRunEntry 8 }
sysApplElmtRunCPU OBJECT-TYPE
SYNTAX TimeTicks
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of centi-seconds of the total system's
CPU resources consumed by this process. Note that
on a multi-processor system, this value may
have been incremented by more than one centi-second
in one centi-second of real (wall clock) time."
::= { sysApplElmtRunEntry 9 }
sysApplElmtRunMemory OBJECT-TYPE
SYNTAX Gauge32
UNITS "Kbytes"
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The total amount of real system memory measured in
Kbytes currently allocated to this process."
::= { sysApplElmtRunEntry 10 }
sysApplElmtRunNumFiles OBJECT-TYPE
SYNTAX Gauge32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The number of regular files currently open by the
process. Transport connections (sockets)
should NOT be included in the calculation of
this value, nor should operating system specific
special file types."
::= { sysApplElmtRunEntry 11 }
sysApplElmtRunUser OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The process owner's login name (e.g. root)."
::= { sysApplElmtRunEntry 12 }Now the sysApplElmtPastRunTable, the processes' memory lane 🦋🌸 It keeps a history, but only for processes that were part of an identifiable application. Lowkey iconic record-keeping.
-- sysApplElmtPastRunTable
-- The sysApplElmtPastRunTable maintains a history of
-- processes which have previously executed on
-- the host as part of an application. Upon termination
-- of a process, the entry representing the process is removed from
-- the sysApplElmtRunTable and a corresponding entry is created in
-- this table provided that the process was part of an
-- identifiable application. If the process could not be associated
-- with an invoked application, no corresponding entry is created.
-- Hence, whereas the sysApplElmtRunTable contains an entry for
-- every process currently executing on the system, the
-- sysApplElmtPastRunTable only contains entries for processes
-- that previously executed as part of an invoked application.
--
-- Entries remain in this table until they are aged out when
-- either the number of entries in the table reaches a
-- maximum as determined by sysApplElmtPastRunMaxRows, or
-- when an entry has aged to exceed a time limit as set by
-- sysApplElmtPastRunTblTimeLimit. When aging out entries,
-- the oldest entry, as determined by the value of
-- sysApplElmtPastRunTimeEnded, will be removed first.
--
-- The table is indexed by sysApplInstallPkgIndex (from the
-- sysApplInstallPkgTable), sysApplElmtPastRunInvocID, and
-- sysApplElmtPastRunIndex to make it easy to locate all
-- previously executed processes of a particular invoked application
-- that has been installed on the system.okay so sysApplElmtPastRunTable is basically the diary of every process that already finished running as part of an installed app 📓✨ it's giving memory keeper, and the whole thing is built so you can find every past process from one invocation without digging through the entire table bestie 🧚
first up, the table itself and its row entry 💖
sysApplElmtPastRunTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplElmtPastRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The table describes the processes which have previously
executed on the host system as part of an application.
Each entry represents a process which has previously
executed and is associated with the invoked application
of which it was a part. Because an invoked application
may involve more than one executable, it is possible
to have multiple entries in this table for
each application invocation. Entries are added
to this table when the corresponding process in the
sysApplElmtRun Table terminates.
Entries remain in this table until they are aged out when
either the number of entries in the table reaches a
maximum as determined by sysApplElmtPastRunMaxRows, or
when an entry has aged to exceed a time limit as set by
sysApplElmtPastRunTblTimeLimit. When aging out entries,
the oldest entry, as determined by the value of
sysApplElmtPastRunTimeEnded, will be removed first.
The table is indexed by sysApplInstallPkgIndex (from the
sysApplInstallPkgTable), sysApplElmtPastRunInvocID,
and sysApplElmtPastRunIndex to make it easy to locate all
previously executed processes of a particular invoked
application that has been installed on the system."
::= { sysApplRun 4 }
sysApplElmtPastRunEntry OBJECT-TYPE
SYNTAX SysApplElmtPastRunEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The logical row describing a process which was
previously executed on this host as part of an
installed application. The entry is basically copied
from the sysApplElmtRunTable when the process
terminates. Hence, the entry's value for
sysApplElmtPastRunIndex is the same as its value
was for sysApplElmtRunIndex. Note carefully: only those
processes which could be associated with an
identified application are included in this table."
INDEX { sysApplInstallPkgIndex, sysApplElmtPastRunInvocID,
sysApplElmtPastRunIndex }
::= { sysApplElmtPastRunTable 1 }
SysApplElmtPastRunEntry ::= SEQUENCE {
sysApplElmtPastRunInvocID Unsigned32,
sysApplElmtPastRunIndex Unsigned32,
sysApplElmtPastRunInstallID Unsigned32,
sysApplElmtPastRunTimeStarted DateAndTime,
sysApplElmtPastRunTimeEnded DateAndTime,
sysApplElmtPastRunName LongUtf8String,
sysApplElmtPastRunParameters Utf8String,
sysApplElmtPastRunCPU TimeTicks,
sysApplElmtPastRunMemory Unsigned32,
sysApplElmtPastRunNumFiles Unsigned32,
sysApplElmtPastRunUser Utf8String
}the entry's index is a little trio of keys: the package index, the invocation ID, and the element index 🎀 together they let you zoom straight to all the past processes from one app run
next up are the index columns, the ones that are not-accessible 🦋 the invocation ID and the element index 🌸
sysApplElmtPastRunInvocID OBJECT-TYPE
SYNTAX Unsigned32 (1..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table, this value
identifies the invocation of an application of which
the process represented by this entry was a part.
The value of this object is the same value as the
sysApplRunIndex for the corresponding application
invocation in the sysApplRunTable. If the invoked
application as a whole has terminated, it will be the
same as the sysApplPastRunIndex."
::= { sysApplElmtPastRunEntry 1 }
sysApplElmtPastRunIndex OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"Part of the index for this table. An integer
assigned by the agent equal to the corresponding
sysApplElmtRunIndex which was removed from the
sysApplElmtRunTable and moved to this table
when the element terminated.
Note: entries in this table are indexed by
sysApplElmtPastRunInvocID, sysApplElmtPastRunIndex.
The possibility exists, though unlikely, of a
collision occurring by a new entry which was run
by the same invoked application (InvocID), and
was assigned the same process identification number
(ElmtRunIndex) as an element which was previously
run by the same invoked application.
Should this situation occur, the new entry replaces
the old entry.
See Section: 'Implementation Issues -
sysApplElmtPastRunTable Entry Collisions' for the
conditions that would have to occur in order for a
collision to occur."
::= { sysApplElmtPastRunEntry 2 }ngl the collision bit is the drama of this whole table 😭 two processes with the same ID from the same app run? the newer one just replaces the older one. the full conditions live in the Implementation Issues section, so go check that if you want the tea 🍓
sysApplElmtPastRunInstallID OBJECT-TYPE
SYNTAX Unsigned32 (1..'ffffffff'h)
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The index into the installed element table. The
value of this object is the same value as the
sysApplInstallElmtIndex for the application element
of which this entry represents a previously executed
process."
::= { sysApplElmtPastRunEntry 3 }
sysApplElmtPastRunTimeStarted OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The time the process was started."
::= { sysApplElmtPastRunEntry 4 }
sysApplElmtPastRunTimeEnded OBJECT-TYPE
SYNTAX DateAndTime
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The time the process ended."
::= { sysApplElmtPastRunEntry 5 }
sysApplElmtPastRunName OBJECT-TYPE
SYNTAX LongUtf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The full path and filename of the process.
For example, '/opt/MYYpkg/bin/myyproc' would
be returned for process 'myyproc' whose execution
path was '/opt/MYYpkg/bin/myyproc'."
::= { sysApplElmtPastRunEntry 6 }
sysApplElmtPastRunParameters OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The starting parameters for the process."
::= { sysApplElmtPastRunEntry 7 }
sysApplElmtPastRunCPU OBJECT-TYPE
SYNTAX TimeTicks
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The last known number of centi-seconds of the total
system's CPU resources consumed by this process.
Note that on a multi-processor system, this value may
increment by more than one centi-second in one
centi-second of real (wall clock) time."
::= { sysApplElmtPastRunEntry 8 }
sysApplElmtPastRunMemory OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
UNITS "Kbytes"
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The last known total amount of real system memory
measured in Kbytes allocated to this process before it
terminated."
::= { sysApplElmtPastRunEntry 9 }
sysApplElmtPastRunNumFiles OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The last known number of files open by the
process before it terminated. Transport
connections (sockets) should NOT be included in
the calculation of this value."
::= { sysApplElmtPastRunEntry 10 }
sysApplElmtPastRunUser OBJECT-TYPE
SYNTAX Utf8String
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The process owner's login name (e.g. root)."
::= { sysApplElmtPastRunEntry 11 }so that's the whole row, every column from the install ID through to the owner's login name 🌈 quick vibe check: the CPU and memory columns are just the last known numbers before the process ended 💅 and sockets don't count toward the open-files count 🧦 (fr, the spec literally says SHOULD NOT, so no sneaking them in 🙈)
and now the scalar knobs that control how big these past-run tables get 👑 they're the bouncers at the door 🫶
-- Additional Scalar objects to control table sizes
sysApplPastRunMaxRows OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The maximum number of entries allowed in the
sysApplPastRunTable. Once the number of rows in
the sysApplPastRunTable reaches this value, the
management subsystem will remove the oldest entry
in the table to make room for the new entry to be added.
Entries will be removed on the basis of oldest
sysApplPastRunTimeEnded value first.
This object may be used to control the amount of
system resources that can used for sysApplPastRunTable
entries. A conforming implementation should attempt
to support the default value, however, a lesser value
may be necessary due to implementation-dependent issues
and resource availability."
DEFVAL { 500 }
::= { sysApplRun 5 }
sysApplPastRunTableRemItems OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"A counter of the number of entries removed from
the sysApplPastRunTable because of table size limitations
as set in sysApplPastRunMaxRows. This counter is the
number of entries the management subsystem has had to
remove in order to make room for new entries (so as not
to exceed the limit set by sysApplPastRunMaxRows) since
the last initialization of the management subsystem."
::= { sysApplRun 6 }
sysApplPastRunTblTimeLimit OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
UNITS "seconds"
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The maximum time in seconds which an entry in the
sysApplPastRunTable may exist before it is removed.
Any entry that is older than this value will be
removed (aged out) from the table.
Note that an entry may be aged out prior to reaching
this time limit if it is the oldest entry in the
table and must be removed to make space for a new
entry so as to not exceed sysApplPastRunMaxRows."
DEFVAL { 7200 }
::= { sysApplRun 7 }
sysApplElemPastRunMaxRows OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The maximum number of entries allowed in the
sysApplElmtPastRunTable. Once the number of rows in
the sysApplElmtPastRunTable reaches this value,
the management subsystem will remove the oldest entry
to make room for the new entry to be added. Entries
will be removed on the basis of oldest
sysApplElmtPastRunTimeEnded value first.
This object may be used to control the amount of
system resources that can used for sysApplElemPastRunTable
entries. A conforming implementation should attempt
to support the default value, however, a lesser value
may be necessary due to implementation-dependent issues
and resource availability."
DEFVAL { 500 }
::= { sysApplRun 8 }so the max-rows knobs default to 500, the time limit defaults to 7200 seconds (that's two hours, bestie ⏰), and the removed-items counter keeps score of every entry that got bounced to make room 🎀 the oldest ones always get the boot first 👢💀
Okay bestie, we're picking up right where the MIB module is still rolling 💅✨
The first bit is the rest of the past-run table's housekeeping. The remove counter tallies how many old rows got kicked out to make room, and the two knobs control the time limit and the agent polling interval 🦋
sysApplElemPastRunTableRemItems OBJECT-TYPE
SYNTAX Counter32
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"A counter of the number of entries removed from the
sysApplElemPastRunTable because of table size limitations
as set in sysApplElemPastRunMaxRows. This counter is the
number of entries the management subsystem has had to
remove in order to make room for new entries (so as not
to exceed the limit set by sysApplElemPastRunMaxRows) since
the last initialization of the management subsystem."
::= { sysApplRun 9 }
sysApplElemPastRunTblTimeLimit OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
UNITS "seconds"
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The maximum time in seconds which an entry in the
sysApplElemPastRunTable may exist before it is removed.
Any entry that is older than this value will be
removed (aged out) from the table.
Note that an entry may be aged out prior to reaching
this time limit if it is the oldest entry in the
table and must be removed to make space for a new
entry so as to not exceed sysApplElemPastRunMaxRows."
DEFVAL { 7200 }
::= { sysApplRun 10 }
sysApplAgentPollInterval OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
UNITS "seconds"
MAX-ACCESS read-write
STATUS current
DESCRIPTION
"The minimum interval in seconds that the management
subsystem implementing this MIB will poll the status
of the managed resources. Because of the non-trivial
effort involved in polling the managed resources,
and because the method for obtaining the status of
the managed resources is implementation-dependent,
a conformant implementation may chose a lower bound
greater than 0.
A value of 0 indicates that there is no delay
in the passing of information from the managed
resources to the agent."
DEFVAL { 60 }
::= { sysApplRun 11 }Next up is the sysApplMap group 🗺️ This one is the backwards lookup table, so if you've got a process ID and want to know which app, element, and package it belongs to, this is your girl 🔥 The comment block explains the whole vibe, so read it closely:
-- sysApplMap Group
-- This group contains a table, the sysApplMapTable,
-- whose sole purpose is to provide a 'backwards'
-- mapping so that, given a known sysApplElmtRunIndex
-- (process identification number), the corresponding invoked
-- application (sysApplRunIndex), installed element
-- (sysApplInstallElmtIndex), and installed application
-- package (sysApplInstallPkgIndex) can be quickly determined.
--
-- The table will contain one entry for each process
-- currently running on the system.
--
-- A backwards mapping is extremely useful since the tables
-- in this MIB module are typically indexed with the
-- installed application package (sysApplInstallPkgIndex)
-- as the primary key, and on down as required by the
-- specific table, with the process ID number (sysApplElmtRunIndex)
-- being the least significant key.
--
-- It is expected that management applications will use
-- this mapping table by doing a 'GetNext' operation with
-- the known process ID number (sysApplElmtRunIndex) as the partial
-- instance identifier. Assuming that there is an entry for
-- the process, the result should return a single columnar value,
-- the sysApplMapInstallPkgIndex, with the sysApplElmtRunIndex,
-- sysApplRunIndex, and sysApplInstallElmtIndex contained in the
-- instance identifier for the returned MIB object value.
--
-- NOTE: if the process can not be associated back to an
-- invoked application installed on the system, then the
-- value returned for the columnar value sysApplMapInstallPkgIndex
-- will be '0' and the instance portion of the object-identifier
-- will be the process ID number (sysApplElmtRunIndex) followed by 0.0.
sysApplMapTable OBJECT-TYPE
SYNTAX SEQUENCE OF SysApplMapEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The sole purpose of this table is to provide a
'backwards' mapping so that, given a known
sysApplElmtRunIndex (process identification number),
the corresponding invoked application (sysApplRunIndex),
installed element (sysApplInstallElmtIndex), and
installed application package (sysApplInstallPkgIndex)
can be quickly determined.
This table will contain one entry for each process
that is currently executing on the system.
It is expected that management applications will use
this mapping table by doing a 'GetNext' operation with
the known process ID number (sysApplElmtRunIndex) as the
partial instance identifier. Assuming that there is an
entry for the process, the result should return a single
columnar value, the sysApplMapInstallPkgIndex, with the
sysApplElmtRunIndex, sysApplRunIndex, and
sysApplInstallElmtIndex contained in the instance identifier
for the returned MIB object value.
NOTE: if the process can not be associated back to an
invoked application installed on the system, then the
value returned for the columnar value
sysApplMapInstallPkgIndex will be '0' and the instance
portion of the object-identifier will be the process ID
number (sysApplElmtRunIndex) followed by 0.0."
::= { sysApplMap 1 }
sysApplMapEntry OBJECT-TYPE
SYNTAX SysApplMapEntry
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"A logical row representing a process currently running
on the system. This entry provides the index mapping from
process identifier, back to the invoked application,
installed element, and finally, the installed application
package. The entry includes only one accessible columnar
object, the sysApplMapInstallPkgIndex, but the
invoked application and installed element can be
determined from the instance identifier since they form
part of the index clause."
INDEX { sysApplElmtRunIndex, sysApplElmtRunInvocID,
sysApplMapInstallElmtIndex }
::= { sysApplMapTable 1 }
SysApplMapEntry ::= SEQUENCE {
sysApplMapInstallElmtIndex Unsigned32,
sysApplMapInstallPkgIndex Unsigned32
}
sysApplMapInstallElmtIndex OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS not-accessible
STATUS current
DESCRIPTION
"The index into the sysApplInstallElmtTable. The
value of this object is the same value as the
sysApplInstallElmtIndex for the application element
of which this entry represents a running instance.
If this process cannot be associated to an installed
executable, the value should be '0'."
::= { sysApplMapEntry 1 }
sysApplMapInstallPkgIndex OBJECT-TYPE
SYNTAX Unsigned32 (0..'ffffffff'h)
MAX-ACCESS read-only
STATUS current
DESCRIPTION
"The value of this object identifies the installed
software package for the application of which this
process is a part. Provided that the process's 'parent'
application can be determined, the value of this object
is the same value as the sysApplInstallPkgIndex for the
entry in the sysApplInstallPkgTable that corresponds
to the installed application of which this process
is a part.
If, however, the 'parent' application cannot be
determined, (for example the process is not part
of a particular installed application), the value
for this object is then '0', signifying that this
process cannot be related back to an application,
and in turn, an installed software package."
::= { sysApplMapEntry 2 }Last stretch of the module: the conformance macros 🎀 These define the compliance statement and the three groups (installed, run, and map), and which ones are MANDATORY for conformance. The object lists are long, so don't skip past them, they're the whole point 💖
-- Conformance Macros
sysApplMIBCompliances OBJECT IDENTIFIER ::= { sysApplConformance 1 }
sysApplMIBGroups OBJECT IDENTIFIER ::= { sysApplConformance 2 }
sysApplMIBCompliance MODULE-COMPLIANCE
STATUS current
DESCRIPTION
"Describes the requirements for conformance to
the System Application MIB"
MODULE -- this module
MANDATORY-GROUPS { sysApplInstalledGroup,
sysApplRunGroup, sysApplMapGroup }
::= { sysApplMIBCompliances 1 }
sysApplInstalledGroup OBJECT-GROUP
OBJECTS { sysApplInstallPkgManufacturer,
sysApplInstallPkgProductName,
sysApplInstallPkgVersion,
sysApplInstallPkgSerialNumber,
sysApplInstallPkgDate,
sysApplInstallPkgLocation,
sysApplInstallElmtName,
sysApplInstallElmtType,
sysApplInstallElmtDate,
sysApplInstallElmtPath,
sysApplInstallElmtSizeHigh,
sysApplInstallElmtSizeLow,
sysApplInstallElmtRole,
sysApplInstallElmtModifyDate,
sysApplInstallElmtCurSizeHigh,
sysApplInstallElmtCurSizeLow }
STATUS current
DESCRIPTION
"The system application installed group contains
information about applications and their constituent
components which have been installed on the host system."
::= { sysApplMIBGroups 1 }
sysApplRunGroup OBJECT-GROUP
OBJECTS { sysApplRunStarted,
sysApplRunCurrentState,
sysApplPastRunStarted,
sysApplPastRunExitState,
sysApplPastRunTimeEnded,
sysApplElmtRunInstallID,
sysApplElmtRunTimeStarted,
sysApplElmtRunState,
sysApplElmtRunName,
sysApplElmtRunParameters,
sysApplElmtRunCPU,
sysApplElmtRunMemory,
sysApplElmtRunNumFiles,
sysApplElmtRunUser,
sysApplElmtPastRunInstallID,
sysApplElmtPastRunTimeStarted,
sysApplElmtPastRunTimeEnded,
sysApplElmtPastRunName,
sysApplElmtPastRunParameters,
sysApplElmtPastRunCPU,
sysApplElmtPastRunMemory,
sysApplElmtPastRunNumFiles,
sysApplElmtPastRunUser,
sysApplPastRunMaxRows,
sysApplPastRunTableRemItems,
sysApplPastRunTblTimeLimit,
sysApplElemPastRunMaxRows,
sysApplElemPastRunTableRemItems,
sysApplElemPastRunTblTimeLimit,
sysApplAgentPollInterval }
STATUS current
DESCRIPTION
"The system application run group contains information
about applications and associated elements which have
run or are currently running on the host system."
::= { sysApplMIBGroups 2 }
sysApplMapGroup OBJECT-GROUP
OBJECTS { sysApplMapInstallPkgIndex }
STATUS current
DESCRIPTION
"The Map Group contains a single table, sysApplMapTable,
that provides a backwards mapping for determining the
invoked application, installed element, and installed
application package given a known process identification
number."
::= { sysApplMIBGroups 3 }
END7. Implementation Issues ✨
okay so this section is all about the real-world stuff that agent developers AND management app developers (or users) should know about this MIB module 💅 it doesn't tell you how to build it, but it does call out the limitations that could actually bite you irl 🫶
7.1. Implementation with Polling Agents
bestie, running System Application MIB stuff on popular operating systems can seriously eat up processing power just to grab status info from the managed resources 😭 and it can be hard to tell when an application or process starts or finishes 💀 so implementors might go with an approach where the agent polls the managed resources at regular intervals. whatever each poll finds gets used to update a cached version of this MIB that lives inside the agent, and SNMP requests get processed using that MIB cache 🧚
the scalar sysApplAgentPollInterval gives the manager control over how often the polling happens 🎀 it's a trade-off ngl: the resources burned on every poll to refresh the cache vs. how accurate the System Application MIB agent's info is 📊 the default is 60 seconds, which keeps the processing overhead chill while still giving usable info for long-lived processes 🦋 a manager is expected to adjust this if it needs more accurate info about short-lived applications or processes, or if the agent is eating way too many resources 💅
7.2. sysApplElmtPastRunTable Entry Collisions
the sysApplElmtPastRunTable keeps a history of processes that previously ran on the host as part of an application 📜 info gets moved over from sysApplElmtRunTable into this PastRun table when the process that an entry represents terminates 🌸
this table is indexed by the tuple (sysApplElmtPastRunInvocID, sysApplElmtPastRunIndex), where the first part identifies the application invocation the process was part of, and the second part identifies the process itself 🫶
quick reminder: sysApplElmtRunIndex is the system's unique identification number for a running process, and that value gets mapped to sysApplElmtPastRunIndex when the process terminates and the entry moves from sysApplElmtRunTable to sysApplElmtPastRunTable 🔁 but lots of systems reuse process ID numbers that aren't assigned to running processes anymore. typically the numbers wrap and the next available number gets used 🙈
so yeah, two entries in sysApplElmtPastRunTable can end up with the same sysApplElmtPastRunIndex 😬 that's why entries are indexed by the (InvocID, RunIndex) tuple, to reduce the chance of a collision between two past run elements with the same sysApplElmtPastRunIndex 🛡️
it's still possible though (unlikely, but possible!) for a collision to happen if:
- the invoked application (identified by InvocID) has an element that runs, terminates, and is moved into the
sysApplElmtPastRunTable(index: InvocID, RunIndex) - the numbers used for the system's process identification numbering wrap
- that same invoked application (same InvocID) has another element process run, AND that process is assigned the same identification number as one of the processes previously run by that invoked application (same RunIndex), and finally,
- that element process terminates and is moved to
sysApplElmtPastRunTablebefore the old, duplicate (InvocID, RunIndex) entry is aged out of the table by the settings defined forsysApplElmtPastRunMaxRowsandsysApplElmtPastRunTblTimeLimit.
if a collision does happen, the new entry replaces the old entry 💖
8. Security Considerations 🔐
bestie, this is the serious bit 🚨 to implement this MIB, an agent must make certain management information available about various logical and physical entities within a managed system. in some network environments, that info may be considered sensitive, so the stakes are highhh 😳
so a network administrator may want to use instance-level access control and configure the access mechanism (i.e., community strings in SNMPv1 and SNMPv2C) so that certain instances within this MIB are excluded from particular MIB views 🔒 protect your secrets, periodt 👑
9. Acknowledgements 🙌
this document was produced by the Application MIB working group. special acknowledgement goes to:
Rick Sturm
Enterprise Management Professional Services, Inc.
sturm@emi-summit.comFor hosting the working group mailing list, and for his participation in the development of the initial draft. 🫶
Jon Weinstock
General Instrument Corporation
jweinstock@gic.gi.comFor his participation in the development of the initial drafts and for serving as editor for drafts 1 and 2. 👑
the editor would like to extend special thanks to the following working group members for their contributions to this effort 🌈
Harald Alvestrand, George Best, Ian Hanson, Harrie Hazewinkel, Carl Kalbfleisch, Bobby Krupczak, Randy Presuhn, Jon Saperia, Juergen Schoenwaelder 💜
11. Author's Address 📮
Cheryl Krupczak
Empire Technologies, Inc.
541 Tenth Street, NW Suite 169
Atlanta, GA 30318
Phone: 770.384.0184
EMail: cheryl@empiretech.com
Jonathan Saperia
BGS Systems Inc.
saperia@networks.bgs.com12. References 📚
[1] Information processing systems - Open Systems
Interconnection - Specification of Abstract Syntax
Notation One (ASN.1), International Organization for
Standardization. International Standard 8824, (December,
1987).
[2] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Structure of Management Information
for Version 2 of the Simple Network Management Protocol
(SNMPv2)", RFC 1902, January 1996.
[3] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Textual Conventions for Version 2 of
the Simple Network Management Protocol (SNMPv2)", RFC
1903, January 1996.
[4] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Conformance Statements for Version 2
of the Simple Network Management Protocol (SNMPv2)", RFC
1904, January 1996.
[5] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Protocol Operations for Version 2 of
the Simple Network Management Protocol (SNMPv2)", RFC
1905, January 1996.
[6] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Transport Mappings for SNMPv2", RFC
1906, January 1996.
[7] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Management Information Base for
Version 2 of the Simple Network Management Protocol
(SNMPv2)", RFC 1907, January 1996.
[8] SNMPv2 Working Group, Case, J., McCloghrie, K., Rose, M.,
and S. Waldbusser, "Coexistence between Version 1 and
Version 2 of the Internet-standard Network Management
Framework", RFC 1908, January 1996.
[9] Grillo, P., and S. Waldbusser, "Host Resources MIB", RFC 1514,
September 1993.
[10] Yergeau, F., "UTF-8, a transformation format of Unicode
and ISO 10646", RFC 2044, October 1996.
[11] Krupczak, C., and S. Waldbusser, "Applicability of Host
Resources MIB to Application Management", Application MIB
working group report, October 1995.12. Full Copyright Statement ⚖️
here's the legal stuff, and it matters, so read it 🫡
Copyright (C) The Internet Society (1998). All Rights Reserved.
This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English.
The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 🦋
📦 where this page comes from
- ietf: rfc2287 1998-02
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms