GENWiki

Premier IT Outsourcing and Support Services within the UK

User Tools

Site Tools


rfc:rfc2564

Network Working Group C. Kalbfleisch Request for Comments: 2564 Verio, Inc. Category: Standards Track C. Krupczak

                                             Empire Technologies, Inc.
                                                            R. Presuhn
                                                    BMC Software, Inc.
                                                            J. Saperia
                                                   IronBridge Networks
                                                              May 1999
                     Application Management MIB

Status of this Memo

 This document specifies an Internet standards track protocol for the
 Internet community, and requests discussion and suggestions for
 improvements.  Please refer to the current edition of the "Internet
 Official Protocol Standards" (STD 1) for the standardization state
 and status of this protocol.  Distribution of this memo is unlimited.

Copyright Notice

 Copyright (C) The Internet Society (1999).  All Rights Reserved.

Abstract

 This memo defines a standards track portion of the Management
 Information Base (MIB) for use with network management protocols in
 the Internet Community.  In particular, it defines objects used for
 the management of applications.  This MIB complements the System
 Application MIB, providing for the management of applications' common
 attributes which could not typically be observed without the
 cooperation of the software being managed.

Table of Contents

 1. Introduction and Overview ...................................    2
 2. The SNMP Management Framework ...............................    4
 3. Architecture ................................................    5
 3.1. Relationships to other MIBs ...............................    5
 3.1.1. Relationship to the System Application MIB ..............    5
 3.1.2. Relationship to the Host Resources MIB ..................    6
 3.1.3. Relationship to NSM .....................................    6
 4. MIB Structure ...............................................    6
 4.1. The service-level tables ..................................    8
 4.1.1. The service name to service instance table ..............    8
 4.1.2. The service instance to service name table ..............    9
 4.1.3. The service instance to running application element table    9
 4.1.4. The running application element to service instance table    9

Kalbfleisch, et al. Standards Track [Page 1] RFC 2564 Application Management MIB May 1999

 4.2. The I/O channel group .....................................    9
 4.2.1. The open channels table .................................   10
 4.2.2. The open files table ....................................   10
 4.2.3. The open connections table ..............................   11
 4.2.4. The transaction stream summary table ....................   12
 4.2.5. The transaction flow statistics table ...................   13
 4.2.6. The transaction kind statistics table ...................   13
 4.3. The former channel group ..................................   13
 4.3.1. The former channel control table ........................   14
 4.3.2. The former channel table ................................   14
 4.3.3. The former connection table .............................   14
 4.3.4. The former file table ...................................   14
 4.3.5. The transaction history tables ..........................   14
 4.4. The running element status and control group ..............   15
 4.4.1. The running application element status table ............   15
 4.4.2. The running application element control table ...........   15
 5. Definitions .................................................   16
 6. Implementation Issues .......................................   80
 7. Intellectual Property .......................................   80
 8. Acknowledgements ............................................   81
 9. Security Considerations .....................................   81
 10. References .................................................   82
 11. Authors' Addresses .........................................   84
 12. Full Copyright Statement ...................................   86

1. Introduction and Overview

 This document furthers the work begun in the systems application MIB
 [31].
 The development of the "Host Resources MIB" [10], "Network Services
 Monitoring MIB" [23], "Mail Monitoring MIB" [24], "Relational
 Database Management System (RDBMS) Management Information Base (MIB)
 using SMIv2" [12], "Entity MIB using SMIv2" [20], and "Applicability
 of Standards Track MIBs to Management of World Wide Web Servers" [21]
 provides us with a base of experience in making a variety of
 applications visible to management; this specification abstracts out
 the common aspects of applications management and provides a generic
 base usable for the management of almost any application.
 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
 "SHOULD", "SHOULD NOT", "RECOMMENDED",  "MAY", and "OPTIONAL" in this
 document are to be interpreted as described in RFC 2119 [22].
 Due to the design decision to not require application
 instrumentation, many important topics were not handled in system
 application MIB [31].  The following topics are within the scope of
 this document:

Kalbfleisch, et al. Standards Track [Page 2] RFC 2564 Application Management MIB May 1999

  1. Support for generic application throughput measurements;
  1. Providing MIB definitions that allow managed entities to

report what they considered to be units of work;

  1. Providing support for generic application response time

monitoring capabilities; (Note that APIs for this purpose

          have already been developed, an example of such an API is to
          be found in the "Application Response Measurement (ARM) API
          Guide, Version 2" [1].)
  1. Provide explicit support for the management of applications

distributed within a single managed system ("local"

          distribution);
  1. Address generic resource management issues, including:
  1. files in use;
  1. I/O statistics (from the application's perspective,

not at the operating system or device driver level);

  1. application-layer networking resource usage
  1. Facilities for the control of applications, including:
  1. Stopping application elements
  1. Suspending and resuming application elements;
  1. Requesting reconfiguration (e.g., SIGHUP).
 Note that these issues are addressed at least in part by other (non-
 IETF) standards work, including "ITU-T Recommendation X.744 | ISO/IEC
 IS 10164-18:1996" [3] and "IEEE P1387.2, POSIX System Administration
 - Part 2: Software Administration" [2].

Kalbfleisch, et al. Standards Track [Page 3] RFC 2564 Application Management MIB May 1999

2. The SNMP Management Framework

 The SNMP Management Framework presently consists of five major
 components:
   An overall architecture, described in RFC 2571 [26].
   Mechanisms for describing and naming objects and events for the
   purpose of management.  The first version of this Structure of
   Management Information (SMI) is called SMIv1 and described in STD
   16, RFC 1155 [4], STD 16, RFC 1212 [6] and RFC 1215 [7].  The
   second version, called SMIv2, is described in STD 58, RFC 2578
   [15], RFC 2579 [16] and RFC 2580 [17].
   Message protocols for transferring management information.  The
   first version of the SNMP message protocol is called SNMPv1 and
   described in STD 15, RFC 1157 [5].  A second version of the SNMP
   message protocol, which is not an Internet standards track
   protocol, is called SNMPv2c and described in RFC 1901 [14] and RFC
   1906 [19].  The third version of the message protocol is called
   SNMPv3 and described in RFC 1906 [19], RFC 2572 [27] and RFC 2574
   [29].
   Protocol operations for accessing management information.  The
   first set of protocol operations and associated PDU formats is
   described in STD 15, RFC 1157 [5].  A second set of protocol
   operations and associated PDU formats is described in RFC 1905
   [18].
   A set of fundamental applications described in RFC 2573 [28] and
   the view-based access control mechanism described in RFC 2575 [30].
 Managed objects are accessed via a virtual information store, termed
 the Management Information Base or MIB.  Objects in the MIB are
 defined using the mechanisms defined in the SMI.
 This memo specifies a MIB module that is compliant to the SMIv2.  A
 MIB conforming to the SMIv1 can be produced through the appropriate
 translations.  The resulting translated MIB must be semantically
 equivalent, except where objects or events are omitted because no
 translation is possible (use of Counter64).  Some machine readable
 information in SMIv2 will be converted into textual descriptions in
 SMIv1 during the translation process.  However, this loss of machine
 readable information is not considered to change the semantics of the
 MIB.

Kalbfleisch, et al. Standards Track [Page 4] RFC 2564 Application Management MIB May 1999

3. Architecture

 Object-oriented modeling techniques like subclassing and multiple
 inheritance can be emulated in the SNMP information model through the
 use of tables with common indexes.
 The challenge for the developer of management applications is to
 recognize those situations in which various aspects of a single
 logical resource are represented in several different tables,
 possibly defined in different MIBs.
 Most of the management information defined here may pertain to any
 number of applications in a managed system.  The simplest way of
 supporting this requirement within the SNMP information model is to
 use tables.  This means that the management information for a
 particular resource may be found in one or more rows of one or more
 tables; the fact that this information pertains to a single resource
 may be inferred from the index values used, possibly with the support
 of mapping tables.  This also means that a single table may contain
 management information relevant to a number of applications.  This
 has significant implementation implications; see the implementation
 issues section below for more information.

3.1. Relationships to other MIBs

 This section outlines the relationships of the components of this MIB
 (usually in the form of common indexing structures) to:
  1. the systems applications MIB [31]
  1. the host resources MIB [10]
  1. the network services monitoring MIB [23]

3.1.1. Relationship to the System Application MIB

 The system application MIB defines attributes for management of
 applications which can be realized without instrumenting the
 application itself.  This specification extends that framework to
 include additional attributes which will typically require
 instrumentation within the managed resource.  The sysApplRunElmtIndex
 is the key connection between these two MIBs; it is essential that
 implementations of this MIB and of the system applications MIB
 running concurrently on a given platform employ a consistent policy
 for assigning this value to identify running application elements.

Kalbfleisch, et al. Standards Track [Page 5] RFC 2564 Application Management MIB May 1999

3.1.2. Relationship to the Host Resources MIB

 The Host Resources MIB [10] supplies information on the hardware,
 operating system, installed and running software on a host.
 The Host Resources MIB has three hardware groups ("hrSystem",
 "hrStorage" and "hrDevice") and three software groups ("hrSWRun",
 "hrSWRunPerf" and "hrSWInstalled").  Of these, the software groups
 are of greatest significance to this MIB.
 The software groups define management information on the software
 used in the system. The information provided is grouped into (1) the
 currently running, (2) the performance and (3) the installed
 applications.
 The index "hrSWRunIndex" used in the "hrSWRunTable" and other tables
 to identify running software by process identifier (or equivalent)
 relates information in the Host Resources MIB to information in the
 System Applications MIB and this MIB. It is essential that the values
 assigned to hrSWRunIndex from the Host Resources MIB be consistent
 with the values used for sysApplRunElmtIndex.

3.1.3. Relationship to NSM

 The Network Services Monitoring MIB [23] is defined as the base set
 of attributes for managing network applications.  The Application MIB
 includes information normally obtainable only from the managed
 resource itself, rather than the supporting system.  Due to
 differences in index representation, the relationship between the
 Network Services Monitoring MIB and the Application MIB is not
 formally defined.

4. MIB Structure

 This MIB is organized into several groups, which in turn are
 organized into tables to provide the monitoring and control of
 information relevant to the management of applications.  The groups
 model:
  1. the service-level view of applications
  1. information on open channels (files, connections,

transaction streams) in use by applications

  1. historical information on former channels
  1. process-level status and control information

Kalbfleisch, et al. Standards Track [Page 6] RFC 2564 Application Management MIB May 1999

 These groups are organized into various tables.  Information for a
 particular running managed application appears in the form of entries
 in the appropriate tables.  The tables are:
  1. the tables providing a service-level view, including:
  1. the service name to service instance table
  1. the service instance to service name table
  1. the service instance to running application element

table

  1. the running application element to service instance

table

  1. the tables providing information on I/O channels, including:
  1. the table of open channels
  1. the table of open files
  1. the open connections table
  1. the transaction statistics tables
  1. historical information on I/O channels
  1. the running application element status and control group
  1. the running application element status table
  1. the running application element control table
 In order to support SNMPv1, SNMPv2, and SNMPv3 environments, in cases
 where counter objects may potentially advance very rapidly, where
 sixty-four bit counters have been used thirty-two bit counters
 reporting the low-order thirty-two bits of the value have also been
 defined.
 Since rows in most of these tables will come and go with the running
 application elements whose information is contained in them,
 sysUpTime.0 is not appropriate as a discontinuity indicator for
 counters in these tables.  By defining separate discontinuity
 indicators for the rows in these tables, entries can come and go as
 needed without causing other objects to appear to have
 discontinuities.  As required by [15], the discontinuity indicators
 for the various information objects in these tables are identified in

Kalbfleisch, et al. Standards Track [Page 7] RFC 2564 Application Management MIB May 1999

 the relevant DESCRIPTION clauses.  Note that a discontinuity in one
 of these counters does not imply a sysUpTime.0 discontinuity, nor
 does a sysUpTime.0 discontinuity imply a discontinuity in any of
 these counters.

4.1. The service-level tables

 The service-level tables permit the identification of one or more
 instances of named services on a system, and the association of
 running application elements to these services.
 Service names are represented as human-readable strings, using values
 assigned by IANA where possible.  The allocation of unique values for
 service instance identifiers is a local administrative issue; the
 values allocated must be constant for the lifetime of the service
 instance, and re-use of values should be avoided.
 It is important to understand that a service is not the same thing as
 a protocol.  Rather, some services may be at least partially
 described by the protocol(s) used to provide that service.
 In deciding what should or should not be considered a service, the
 following factors merit consideration:
  1. is there an identifiable set of resources associated with

providing this service?

  1. is there a reasonably long-lived server or client process?
 Following this reasoning, one can see where SMTP and HTTP service
 providers would be good candidates for classification as services for
 purposes of application management, where finger probably would not.
 Of course, implementors of this MIB are free to define additional
 services.  An applicability statement may be an appropriate vehicle
 for standardizing how a specific service's information is reported
 using this MIB.

4.1.1. The service name to service instance table

 The service name to service instance table uses the service name as
 its primary key, and the service instance identifier as its secondary
 key.  It facilitates the identification and lookup of the instances
 of a given service in a system.

Kalbfleisch, et al. Standards Track [Page 8] RFC 2564 Application Management MIB May 1999

4.1.2. The service instance to service name table

 The service instance to service name table uses the service instance
 identifier as its primary key, and the service name as its secondary
 key.  Given a service instance identifier, it facilitates the lookup
 of the name of the service being provided.

4.1.3. The service instance to running application element table

 The service instance to running application element table uses the
 service instance identifier as its primary key, and the running
 application element index as its secondary key.  This facilitates the
 identification of the set of running application elements providing a
 given instance of a service.

4.1.4. The running application element to service instance table

 The running application element to service instance table uses the
 running application element index as its primary key and the service
 instance identifier as its secondary key.  It identifies the set of
 services provided by a given running application element.

4.2. The I/O channel group

 Information processed by an application can be modeled using the
 concept of a channel.  Two kinds of channels, for example, are files
 and network connections.
                                                +-------+
                                                | File  |
                           +---------+         /+-------+
        +-------------+    | Generic |        /
        | transaction |----|  I/O    |-------<
        |   stream    |    | Channel |        \  +------------+
        +-------------+    +---------+         \ | open or    |
                                                \| listening  |
                                                 | connection |
                                                 +------------+
 For each entry in the open channel table, there will be a
 corresponding entry in either the open file table or the open
 connection table.
 The information flowing on a channel may be structured as
 transactions.  When the information flow on a channel is being
 monitored as a transaction stream, an entry in the transaction stream
 table will represent this fact and the associated information about

Kalbfleisch, et al. Standards Track [Page 9] RFC 2564 Application Management MIB May 1999

 that stream.
 To facilitate traversal of these tables and retrieval of information
 relevant to a specific running application element or service
 instances, the initial indexes of these tables are the same.  In each
 case, the first index determines whether the second index is
 interpreted as a running application element identifier or as a
 service instance identifier.  The third index serves to uniquely
 identify a channel (and consequently, an open connection or file) in
 the context of a running application element or service instance.
 The transaction stream summary table contains per-stream summaries of
 transaction statistics.  The transaction flow statistics table
 contains statistics broken into both transmit and receive counts for
 requests and responses on each stream.  The transaction kind
 statistics table contains information further broken down by
 transaction kind.
 The transaction tables have a common structure for their indexing,
 with additional indexes added for increasing detail.  The initial
 three indexes are the same as all the other tables in this group,
 serving to uniquely identify each transaction stream.

4.2.1. The open channels table

 The following information is available in this table:
  1. time at which the channel was opened
  1. number of read requests
  1. number of bytes read
  1. time at which most recent read operation was initiated
  1. number of write requests
  1. number of bytes written
  1. time at which most recent write operation was initiated

4.2.2. The open files table

 The open files table contains one entry for each file in use by a
 manageable running application element.  (See "Definitions of
 System-Level Managed Objects for Applications" [31] for a detailed
 definition of a running application element.)  The purpose of this
 table is to identify the files in use and to record information

Kalbfleisch, et al. Standards Track [Page 10] RFC 2564 Application Management MIB May 1999

 peculiar to files not already covered in the open channel table.
 If multiple running application elements open the same file, there
 will be an entry for each running application element opening that
 file.  Similarly, if a running application element opens a file
 multiple times, there will be an entry in this table for the file
 corresponding to each open.
 The task of combining the information for file activity from this
 table (organized by running application element) into per-application
 statistics can be accomplished by a manager using the System
 Application MIB's [31] sysApplInstallPkgTable to find the installed
 application, the sysApplRunTable to find the running instances of
 that application, and the sysApplElmtRunTable to find the relevant
 values of sysApplElmtRunIndex.  The manager, armed with a set of
 values for sysApplElmtRunIndex, is now able to retrieve the relevant
 portions of the applOpenFileTable and other tables in this MIB.
 The following information is available in this table:
  1. file name
  1. file size
  1. current mode (read/write) of this file
 By convention, the names "stdin", "stdout" and "stderr" are used when
 these streams cannot be resolved to actual file names.

4.2.3. The open connections table

 This table provides information on channels that are open connections
 or listeners.
 The following information is available for each connection:
  1. identification of the transport protocol in use
  1. near-end address and port
  1. far-end address and port
  1. identification of the application layer protocol in use

Kalbfleisch, et al. Standards Track [Page 11] RFC 2564 Application Management MIB May 1999

4.2.4. The transaction stream summary table

 The transaction stream summary table contains per-stream summaries of
 transaction statistics.  The simple model of a transaction used here
 looks like this:
                 invoker  |   Request     | performer
                          | - - - - - - > |
                          |               |
                          |   Response    |
                          | < - - - - - - |
                          |               |
 Since in some protocols it is possible for an entity to take on both
 the invoker and performer roles, information here is accumulated for
 transmitted and received requests, as well as for transmitted and
 received responses.  Counts are maintained for both transactions and
 bytes transferred.  The information represented in this table
 includes:
  1. identification of the underlying connection or file used for

this transaction stream

  1. a human-readable description of this stream
  1. a human-readable description of this stream's notion of what

a unit of work is

  1. the cumulative amount of time spent (as an operation

invoker) waiting for responses (from queueing of request to

          arrival of first response)
  1. the cumulative amount of time spent (as an operation

invoker) receiving responses (time from the arrival of the

          first response to the arrival of the last response in a
          series of responses to a particular request)
  1. the cumulative amount of time spent (as an operation

performer) handling requests (time from receipt of request

          to queueing of first outgoing response)
  1. the cumulative amount of time spent (as an operation

performer) sending responses (time from queuing of first

          response to the last response in a series of responses to a
          particular request)

Kalbfleisch, et al. Standards Track [Page 12] RFC 2564 Application Management MIB May 1999

  1. the cumulative number of transactions initiated (as an

invoker)

  1. the cumulative number of transactions processed (as a

performer)

4.2.5. The transaction flow statistics table

 The transaction flow statistics table contains statistics broken into
 both transmit and receive counts for requests and responses on each
 stream.  In addition to the service instance / running application
 element and transaction stream identifier indexes, rows in this table
 are indexed by flow direction (transmit or receive) and role
 (requests and responses).  The information in this table includes:
  1. the number of transactions processed
  1. the number of bytes processed
  1. the time at which the most recent transaction was processed

in this flow

4.2.6. The transaction kind statistics table

 The transaction kind statistics table contains summary information
 organized by direction, request/response, and transaction kind for
 each stream.  The indexing of this table is like that of the
 transaction flow table, with the addition of a transaction kind
 index.
  1. number of transactions processed
  1. number of bytes processed
  1. the time at which the most recent transaction of this kind

in this direction in this stream was processed

4.3. The former channel group

 The former channel group has several tables.  The former channel
 control table controls the retention of history information by a
 running application element or service instance.  The remaining
 tables parallel the structure of the channel group, with one
 significant difference in indexing structure.  The closed channel
 index is independent from the open channel index.

Kalbfleisch, et al. Standards Track [Page 13] RFC 2564 Application Management MIB May 1999

4.3.1. The former channel control table

 The former channel control table provides control over the
 accumulation of information on former connections for running
 application elements and service instances.  For each one, this
 table, indexed by the running application element or service instance
 index, controls whether information on former channels is
 accumulated, how many of these history records are retained, how long
 these are retained (within the lifetime of the process), and a count
 of history entries that were deleted before their expiration time in
 order to make room for new entries.

4.3.2. The former channel table

 The former channel table provides historical information on channels
 that have been closed.  The number and lifetime of these entries is
 controlled, for each running application element or service instance,
 by the former channel control table.  Most of the information in this
 table corresponds to information in the open channel table.
 For the connection or file-specific aspects of a given former
 channel, an entry will exist in the former connection table or in the
 former file table.

4.3.3. The former connection table

 For formerly open channels that were connections, connection-specific
 historical information is kept in the former connection table.  For
 each entry in the former connection table, there will be an
 identically indexed entry in the former channel table.

4.3.4. The former file table

 For formerly open channels that were files, file-specific historical
 information is kept in the former file table.  For each entry in the
 former file table, there will be an identically indexed entry in the
 former channel table.

4.3.5. The transaction history tables

 Two tables provide per-transaction-kind breakdowns for channels
 carrying transaction-structured flows.  These tables are analogous to
 the transaction flow and kind statistics tables, with similar index
 structures.

Kalbfleisch, et al. Standards Track [Page 14] RFC 2564 Application Management MIB May 1999

4.4. The running element status and control group

 The running application element status and control group has two
 tables.

4.4.1. The running application element status table

 This table provides information for a running application element.
 Indexed by the sysApplElmtRunIndex, an entry in this table reports
 useful information on that running element's resource usage.  Entries
 in this table contain:
  1. current heap usage for this running application element
  1. current number of open network connections for this running

application element

  1. the most recent error status message issued by this running

application element

 Note that other information, such as the current number of open files
 for this running application element, is available from the
 sysapplElmtRunTable in [31].

4.4.2. The running application element control table

 This table provides rudimentary control over a running application
 element.  Indexed by the sysApplElmtRunIndex, an entry in this table
 gives a manager with appropriate permissions the ability to suspend
 and resume processing by this running element, the ability to request
 reconfiguration, and the ability to terminate the running element.
 Variables in this table include:
  1. a suspend/resume control
  1. a reconfiguration request control
  1. a termination request control

Kalbfleisch, et al. Standards Track [Page 15] RFC 2564 Application Management MIB May 1999

5. Definitions

 APPLICATION-MIB DEFINITIONS ::= BEGIN
 IMPORTS
     MODULE-IDENTITY, OBJECT-TYPE,
         Counter64, Counter32, Gauge32,
         mib-2, Unsigned32, zeroDotZero   FROM SNMPv2-SMI
     DateAndTime, TEXTUAL-CONVENTION,
         TestAndIncr, TDomain,
         TimeStamp, TruthValue            FROM SNMPv2-TC
     SnmpAdminString                      FROM SNMP-FRAMEWORK-MIB
     MODULE-COMPLIANCE, OBJECT-GROUP
                                          FROM SNMPv2-CONF
     LongUtf8String, sysApplElmtRunIndex  FROM SYSAPPL-MIB;
 applicationMib MODULE-IDENTITY
     LAST-UPDATED "9811171815Z"
     ORGANIZATION "Application MIB Working Group"
     CONTACT-INFO
        "http://www.ietf.org/html.charters/applmib-charter.html
         Randy Presuhn
         BMC Software, Inc.
         965 Stewart Drive
         Sunnyvale, CA 94086
         USA
         Telephone: +1 408 616-3100
         Facsimile: +1 408 616-3101
         EMail: randy_presuhn@bmc.com
        "
     DESCRIPTION
        "This MIB defines objects representing generic aspects of
         applications that are of interest to management but typically
         require instrumentation within managed application elements.
        "
     ::= { mib-2 62 }
  1. -
  2. - Registration hierarchy for this MIB
  3. -

applicationMibObjects OBJECT IDENTIFIER ::=

                          { applicationMib 1 }

Kalbfleisch, et al. Standards Track [Page 16] RFC 2564 Application Management MIB May 1999

 applicationMibConformance OBJECT IDENTIFIER ::=
                          { applicationMib 2 }
  1. -
  2. - Groups defined in this MIB
  3. -

applServiceGroup OBJECT IDENTIFIER ::=

                          { applicationMibObjects 1 }
 applChannelGroup OBJECT IDENTIFIER ::=
                          { applicationMibObjects 2 }
 applPastChannelGroup OBJECT IDENTIFIER ::=
                          { applicationMibObjects 3 }
 applElmtRunControlGroup OBJECT IDENTIFIER ::=
                          { applicationMibObjects 4 }
 Unsigned64TC ::= TEXTUAL-CONVENTION
     STATUS current
     DESCRIPTION
         "A non-negative 64-bit bit integer, without counter
          semantics."
     SYNTAX Counter64
 ApplTAddress ::= TEXTUAL-CONVENTION
     STATUS       current
     DESCRIPTION
           "Denotes a transport service address.
           For snmpUDPDomain, an ApplTAddress is 6 octets long,
           the initial 4 octets containing the IP-address in
           network-byte order and the last 2 containing the UDP
           port in network-byte order.  Consult 'Transport Mappings
           for Version 2 of the Simple Network Management Protocol
           (SNMPv2)' for further information on snmpUDPDomain."
     SYNTAX       OCTET STRING (SIZE (0..255))

Kalbfleisch, et al. Standards Track [Page 17] RFC 2564 Application Management MIB May 1999

  1. -
  2. -
  3. - applServiceGroup -
  4. -
  5. - The service-level tables permit the identification of one
  6. - or more instances of named services on a system, and the
  7. - association of running application elements to services.
  8. -
  9. -
  1. -
  2. -
  3. - The service name to service instance table
  4. -
  5. -
 applSrvNameToSrvInstTable OBJECT-TYPE
         SYNTAX            SEQUENCE OF ApplSrvNameToSrvInstEntry
         MAX-ACCESS        not-accessible
         STATUS            current
         DESCRIPTION
            "The service name to service instance table uses
             service name as its primary key, and service instance
             identifier as its secondary key.  It facilitates the
             identification and lookup of the instances of a given
             service in a system."
         ::= { applServiceGroup 1 }
 applSrvNameToSrvInstEntry OBJECT-TYPE
         SYNTAX            ApplSrvNameToSrvInstEntry
         MAX-ACCESS        not-accessible
         STATUS            current
         DESCRIPTION
            "An applSrvNameToSrvInstEntry identifies an instance of
             a given service.  The allocation and reservation
             of unique values for applSrvIndex is an administrative
             issue.
             An applSrvNameToSrvInstEntry exists for the lifetime of
             that instance of that service; the index values may not
             change during that lifetime.  "
         INDEX { applSrvName, applSrvIndex }
         ::= { applSrvNameToSrvInstTable 1 }

Kalbfleisch, et al. Standards Track [Page 18] RFC 2564 Application Management MIB May 1999

 ApplSrvNameToSrvInstEntry ::= SEQUENCE
         {
                 applSrvInstQual SnmpAdminString
         }
 applSrvInstQual         OBJECT-TYPE
         SYNTAX          SnmpAdminString
         MAX-ACCESS      read-only
         STATUS          current
         DESCRIPTION
            "The value of applSrcInstQual provides additional
             information about this particular instance of this
             service.
             Although not used for indexing purposes, the value of
             this attribute should be sufficiently unique to be
             helpful to an administrator in distinguishing among
             service instances.  "
         ::= { applSrvNameToSrvInstEntry 1 }
  1. -
  2. -
  3. - Service instance to Service Name table
  4. -
  5. -
 applSrvInstToSrvNameTable OBJECT-TYPE
         SYNTAX            SEQUENCE OF ApplSrvInstToSrvNameEntry
         MAX-ACCESS        not-accessible
         STATUS            current
         DESCRIPTION
            "The service instance to service name table uses
             service instance identifier as its primary key, and
             service name as its secondary key.  Given a service
             instance identifier, it facilitates the lookup of the
             name of the service being provided."
         ::= { applServiceGroup 2 }

Kalbfleisch, et al. Standards Track [Page 19] RFC 2564 Application Management MIB May 1999

 applSrvInstToSrvNameEntry OBJECT-TYPE
         SYNTAX            ApplSrvInstToSrvNameEntry
         MAX-ACCESS        not-accessible
         STATUS            current
         DESCRIPTION
            "An applSrvInstToSrvNameEntry maps a service instance
             identifier back to a service name."
         INDEX { applSrvIndex, applSrvName }
         ::= { applSrvInstToSrvNameTable 1 }
 ApplSrvInstToSrvNameEntry ::= SEQUENCE
         {
                 applSrvName     SnmpAdminString
         }
 applSrvName        OBJECT-TYPE
         SYNTAX     SnmpAdminString
         MAX-ACCESS read-only
         STATUS     current
         DESCRIPTION
            "The human-readable name of a service.  Where
             appropriate, as in the case where a service can be
             identified in terms of a single protocol, the strings
             should be established names such as those assigned by
             IANA and found in STD 2 [13], or defined by some other
             authority.  In some cases private conventions apply
             and the string should in these cases be consistent
             with these non-standard conventions.   An applicability
             statement may specify the service name(s) to be used.
            "
         ::= { applSrvInstToSrvNameEntry 1 }
  1. -
  2. -
  3. - The service instance to running application element table
  4. -
  5. -
 applSrvInstToRunApplElmtTable OBJECT-TYPE
         SYNTAX            SEQUENCE OF ApplSrvInstToRunApplElmtEntry
         MAX-ACCESS            not-accessible
         STATUS                current
         DESCRIPTION
            "The service instance to running application element
             table uses the service instance identifier as its primary
             key, and the running application element index as its
             secondary key.  This facilitates the identification

Kalbfleisch, et al. Standards Track [Page 20] RFC 2564 Application Management MIB May 1999

             of the set of running application elements providing a
             given instance of a service."
         ::= { applServiceGroup 3 }
 applSrvInstToRunApplElmtEntry OBJECT-TYPE
         SYNTAX                ApplSrvInstToRunApplElmtEntry
         MAX-ACCESS            not-accessible
         STATUS                current
         DESCRIPTION
            "An applSrvInstToRunApplElmtEntry identifies a running
             application element providing an instance of a service.
             Note that there may be multiple running application
             elements involved in the provision of an instance of
             a service."
         INDEX { applSrvIndex, sysApplElmtRunIndex }
         ::= { applSrvInstToRunApplElmtTable 1 }
 ApplSrvInstToRunApplElmtEntry ::= SEQUENCE
         {
                 applSrvIndex       Unsigned32
         }
 applSrvIndex        OBJECT-TYPE
         SYNTAX      Unsigned32 (1..'ffffffff'h)
         MAX-ACCESS  read-only
         STATUS      current
         DESCRIPTION
             "An applSrvIndex is the system-unique identifier of
              an instance of a service.  The value is unique not only
              across all instances of a given service, but also across
              all services in a system.
              Re-use of values for this index should be avoided.
              No two service instances in a given system shall
              concurrently have the same value for this index.
              The value zero is excluded from the set of permitted
              values for this index.  This allows other tables to
              potentially represent things which cannot be associated
              with a specific service instance.
             "
         ::= { applSrvInstToRunApplElmtEntry 1 }

Kalbfleisch, et al. Standards Track [Page 21] RFC 2564 Application Management MIB May 1999

  1. -
  2. -
  3. - The running application element to service instance table
  4. -
  5. -
 applRunApplElmtToSrvInstTable OBJECT-TYPE
         SYNTAX           SEQUENCE OF ApplRunApplElmtToSrvInstEntry
         MAX-ACCESS            not-accessible
         STATUS                current
         DESCRIPTION
            "The running application element to service instance
             table uses the running application element index as
             its primary key and the service instance identifier as
             its secondary key.  It identifies the set of services
             provided by a given running application element."
         ::= { applServiceGroup 4 }
 applRunApplElmtToSrvInstEntry OBJECT-TYPE
         SYNTAX                ApplRunApplElmtToSrvInstEntry
         MAX-ACCESS            not-accessible
         STATUS                current
         DESCRIPTION
            "An applRunApplElmtToSrvInstEntry serves to identify an
             instance of a service being provided by a given running
             application element.  Note that a particular running
             application element may provide multiple services."
         INDEX { sysApplElmtRunIndex, applSrvInstance }
         ::= { applRunApplElmtToSrvInstTable 1 }
 ApplRunApplElmtToSrvInstEntry ::= SEQUENCE
         {
                 applSrvInstance         Unsigned32
         }
 applSrvInstance    OBJECT-TYPE
         SYNTAX     Unsigned32 (1..'ffffffff'h)
         MAX-ACCESS read-only
         STATUS     current
         DESCRIPTION
            "An applSrvInstance is the system-unique identifier of an
             instance of a service.  The value is unique not only
             across all instances of a given service, but also across
             all services.
             Re-use of values for this index should be avoided.
             No two service instances in a given system shall
             concurrently have the same value for this index.

Kalbfleisch, et al. Standards Track [Page 22] RFC 2564 Application Management MIB May 1999

             The value zero is excluded from the set of permitted
             values for this index.  This allows other tables to
             potentially represent things which cannot be associated
             with a specific service instance.
             This attribute is semantically identical to
             applSrvIndex."
         ::= { applRunApplElmtToSrvInstEntry  1 }
  1. -
  2. -
  3. - applChannelGroup - group with tables for I/O
  4. -
  5. - In this group, the common abstraction is the Channel.
  6. - Channels are realized as files or connections.
  7. - The information flowing on a channel can always be
  8. - measured in terms of a byte stream. Furthermore, for many
  9. - channels, this information may also be measured in terms
  10. - of transactions.
  11. -
  12. - For all of these tables, the first two indexes determines
  13. - whether what is being measured is for a single running
  14. - application element or for an instance of a service.
  15. -
  16. - The second index identifies the running application element
  17. - or service instance.
  18. -
  19. - The third index is the channel id, which uniquely identifies
  20. - a channel within the context of a running application element
  21. - or service instance.
  22. -
  23. - Any remaining indexes are table-specific.
  24. -
  25. -
  1. -
  2. -
  3. - applOpenChannelTable - Table of Open Channels
  4. -
  5. -
 applOpenChannelTable OBJECT-TYPE
         SYNTAX       SEQUENCE OF ApplOpenChannelEntry
         MAX-ACCESS   not-accessible
         STATUS       current

Kalbfleisch, et al. Standards Track [Page 23] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "The applOpenChannelTable reports information on open
             channels for running application elements
             and for service instances.  This table is
             indexed by applElmtOrSvc, applElmtOrSvcId, and
             applOpenChannelIndex. This effectively groups all
             entries for a given running application element
             or service instance together.  ApplChannelIndex uniquely
             identifies an open channel (and, consequently, a file
             or connection) within the context of a particular
             running application element or service instance.
             Some of the information in this table is available
             through both sixty-four and thirty-two bit counters.
             The sixty-four bit counters are not accessible in
             protocols that do not support this data type."
         ::= { applChannelGroup 1 }
 applOpenChannelEntry OBJECT-TYPE
         SYNTAX       ApplOpenChannelEntry
         MAX-ACCESS   not-accessible
         STATUS       current
         DESCRIPTION
            "An applOpenChannelEntry indicates that a channel has been
             opened by this running application element or service
             instance and is still open.  Note that if a file has been
             opened multiple times, even by the same process, it will
             have multiple channel entries."
         INDEX           { applElmtOrSvc, applElmtOrSvcId,
                           applOpenChannelIndex }
         ::= { applOpenChannelTable 1 }
 ApplOpenChannelEntry  ::= SEQUENCE
         {
                 applElmtOrSvc                      INTEGER,
                 applElmtOrSvcId                    Unsigned32,
                 applOpenChannelIndex               Unsigned32,
                 applOpenChannelOpenTime            TimeStamp,
                 applOpenChannelReadRequests        Counter64,
                 applOpenChannelReadRequestsLow     Counter32,
                 applOpenChannelReadFailures        Counter32,
                 applOpenChannelBytesRead           Counter64,
                 applOpenChannelBytesReadLow        Counter32,
                 applOpenChannelLastReadTime        DateAndTime,
                 applOpenChannelWriteRequests       Counter64,
                 applOpenChannelWriteRequestsLow    Counter32,
                 applOpenChannelWriteFailures       Counter32,
                 applOpenChannelBytesWritten        Counter64,

Kalbfleisch, et al. Standards Track [Page 24] RFC 2564 Application Management MIB May 1999

                 applOpenChannelBytesWrittenLow     Counter32,
                 applOpenChannelLastWriteTime       DateAndTime
         }
 applElmtOrSvc      OBJECT-TYPE
         SYNTAX     INTEGER { service(1),
                              element(2) }
         MAX-ACCESS not-accessible
         STATUS     current
         DESCRIPTION
            "The applElmtOrSvc attribute serves as an index for tables
             that can hold information both for individual running
             application elements as well as for service instances.
             If the value is service(1), the row contains information
             gathered at the level of a service.
             If the value is element(2), the row contains information
             for an individual running application element."
         ::= { applOpenChannelEntry 1 }
 applElmtOrSvcId    OBJECT-TYPE
         SYNTAX     Unsigned32 (1..'ffffffff'h)
         MAX-ACCESS not-accessible
         STATUS     current
         DESCRIPTION
            "The applElmtOrSvcId attribute is used as an index in
             conjunction with the applElmtOrSvc attribute.
             When the value of applElmtOrSvc is service(1), this
             attribute's value corresponds to that of applSrvIndex,
             when the value of applElmtOrSvc is element(2), this
             attribute's value corresponds to sysApplElmtRunIndex."
         ::= { applOpenChannelEntry 2 }
 applOpenChannelIndex OBJECT-TYPE
         SYNTAX       Unsigned32
         MAX-ACCESS   not-accessible
         STATUS       current
         DESCRIPTION
            "This attribute serves to uniquely identify this open
             connection in the context of the running application
             element or service instance.  Where suitable, the
             application's native descriptor number should be used."
         ::= { applOpenChannelEntry 3 }

Kalbfleisch, et al. Standards Track [Page 25] RFC 2564 Application Management MIB May 1999

 applOpenChannelOpenTime OBJECT-TYPE
         SYNTAX          TimeStamp
         MAX-ACCESS      read-only
         STATUS          current
         DESCRIPTION
            "This attribute records the value of sysUpTime.0
             when this channel was opened and this entry was added to
             this table.  This attribute serves as a discontinuity
             indicator for the counter attributes in this entry
             and for any corresponding entries in the
             applOpenConnectionTable, applOpenFileTable, and the
             applTransactionStreamTable."
         ::= { applOpenChannelEntry 4 }
 applOpenChannelReadRequests OBJECT-TYPE
         SYNTAX              Counter64
         UNITS               "read requests"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute reports the number of read requests
             for this channel.  All read requests for this channel
             by this entity, regardless of completion status, are
             included in this count.
             Read requests are counted in terms of system calls,
             rather than API calls.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 5 }
 applOpenChannelReadRequestsLow OBJECT-TYPE
         SYNTAX                 Counter32
         UNITS                  "read requests"
         MAX-ACCESS             read-only
         STATUS                 current
         DESCRIPTION
            "This attribute reports the low thirty-two bits of
             applOpenChannelReadRequests.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 6 }

Kalbfleisch, et al. Standards Track [Page 26] RFC 2564 Application Management MIB May 1999

 applOpenChannelReadFailures OBJECT-TYPE
         SYNTAX              Counter32
         UNITS               "failed read requests"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute reports the number of failed read
             requests.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 7 }
 applOpenChannelBytesRead OBJECT-TYPE
         SYNTAX           Counter64
         UNITS            "bytes"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "This attribute reports the number of bytes read from
             this channel.  Only bytes successfully read are included
             in this count.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 8 }
 applOpenChannelBytesReadLow OBJECT-TYPE
         SYNTAX              Counter32
         UNITS               "bytes"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two bits
             of applOpenChannelBytesRead.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 9 }
 applOpenChannelLastReadTime OBJECT-TYPE
         SYNTAX              DateAndTime
         MAX-ACCESS          read-only
         STATUS              current

Kalbfleisch, et al. Standards Track [Page 27] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "This attribute reports the time of the most recent read
             request made by this entity, regardless of completion
             status, for this open channel.
             If no read requests have been made the value of this
             attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applOpenChannelEntry 10 }
 applOpenChannelWriteRequests OBJECT-TYPE
         SYNTAX               Counter64
         UNITS                "write requests"
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "This attribute reports the number of write requests for
             this channel made by this entity.  All write requests
             for this channel, regardless of completion status, are
             included in this count.
             Write requests are counted in terms of system calls,
             rather than API calls.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 11 }
 applOpenChannelWriteRequestsLow OBJECT-TYPE
         SYNTAX                  Counter32
         UNITS                   "write requests"
         MAX-ACCESS              read-only
         STATUS                  current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two bits
             of applOpenChannelWriteRequests.
             Discontinuities in this counter can be detected
             by monitoring the applOpenChannelOpenTime value for
             this entry."
         ::= { applOpenChannelEntry 12 }
 applOpenChannelWriteFailures OBJECT-TYPE
         SYNTAX               Counter32
         UNITS                "failed write requests"
         MAX-ACCESS           read-only
         STATUS               current

Kalbfleisch, et al. Standards Track [Page 28] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "This attribute reports the number of failed write
             requests.
             Discontinuities in this counter can be detected
             by monitoring the applOpenChannelOpenTime value for
             this entry."
         ::= { applOpenChannelEntry 13 }
 applOpenChannelBytesWritten OBJECT-TYPE
         SYNTAX              Counter64
         UNITS               "bytes"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute reports the number of bytes written to
             this channel.  Only bytes successfully written (without
             errors reported by the system to the API in use by the
             application) are included in this count.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 14 }
 applOpenChannelBytesWrittenLow OBJECT-TYPE
         SYNTAX                 Counter32
         UNITS                  "bytes"
         MAX-ACCESS             read-only
         STATUS                 current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two bits
             of applOpenChannelBytesWritten.
             Discontinuities in this counter can be detected by
             monitoring the applOpenChannelOpenTime value for this
             entry."
         ::= { applOpenChannelEntry 15 }
 applOpenChannelLastWriteTime OBJECT-TYPE
         SYNTAX               DateAndTime
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "This attribute reports the time of the most recent write
             request made by this running application element or
             service instance, regardless of completion status, for
             this open channel.

Kalbfleisch, et al. Standards Track [Page 29] RFC 2564 Application Management MIB May 1999

             If no write requests have been made, the value
             of this attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applOpenChannelEntry 16 }
  1. -
  2. -
  3. - applOpenFileTable - Table of Open Files
  4. -
  5. -
 applOpenFileTable  OBJECT-TYPE
         SYNTAX     SEQUENCE OF ApplOpenFileEntry
         MAX-ACCESS not-accessible
         STATUS     current
         DESCRIPTION
            "The applOpenFileTable reports information on open files
             for service instances or application elements.  This
             table is indexed by applElmtOrSvc and applElmtOrSvcId,
             effectively grouping all entries for a given running
             service instance or application element together, and
             by applOpenChannelIndex, uniquely identifying an open
             channel (and, consequently, a file) within the context
             of a particular service instance or application element.
             Elements in this table correspond to elements in the
             applOpenChannelTable that represent files.  For rows in
             the applOpenChannelTable that do not represent files,
             corresponding rows in this table will not exist."
         ::= { applChannelGroup 2 }
 applOpenFileEntry   OBJECT-TYPE
         SYNTAX      ApplOpenFileEntry
         MAX-ACCESS  not-accessible
         STATUS      current
         DESCRIPTION
            "An applOpenFileEntry indicates that a file has been
             opened by this running application element and is
             still open.  Note that if a file has been opened
             multiple times, even by the same process, it will have
             multiple entries."
         INDEX       { applElmtOrSvc, applElmtOrSvcId,
                       applOpenChannelIndex }
         ::= { applOpenFileTable 1 }

Kalbfleisch, et al. Standards Track [Page 30] RFC 2564 Application Management MIB May 1999

 ApplOpenFileEntry  ::= SEQUENCE
         {
                 applOpenFileName                LongUtf8String,
                 applOpenFileSizeHigh            Unsigned32,
                 applOpenFileSizeLow             Unsigned32,
                 applOpenFileMode                INTEGER
          }
 applOpenFileName   OBJECT-TYPE
         SYNTAX     LongUtf8String
         MAX-ACCESS read-only
         STATUS     current
         DESCRIPTION
           "This attribute reports the name of this open file.
            Wherever practical, a fully qualified path name should
            be reported.
            The values 'stdin', 'stdout', and 'stderr' are reserved
            in accordance with common usage when the fully qualified
            path name cannot be determined."
         ::= { applOpenFileEntry 1 }
 applOpenFileSizeHigh OBJECT-TYPE
         SYNTAX       Unsigned32
         UNITS        "2^32 byte blocks"
         MAX-ACCESS   read-only
         STATUS       current
         DESCRIPTION
           "This file's current size in 2^32 byte blocks.
            For example, for a file with a total size of 4,294,967,296
            bytes, this attribute would have a value of 1; for a file
            with a total size of 4,294,967,295 bytes this attribute's
            value would be 0."
         ::= { applOpenFileEntry 2 }
 applOpenFileSizeLow OBJECT-TYPE
         SYNTAX      Unsigned32
         UNITS       "bytes"
         MAX-ACCESS  read-only
         STATUS      current
         DESCRIPTION
            "This file's current size modulo 2^32 bytes.
             For example, for a file with a total size of
             4,294,967,296 bytes this attribute would have a value
             of 0; for a file with a total size of 4,294,967,295
             bytes this attribute's value would be 4,294,967,295."

Kalbfleisch, et al. Standards Track [Page 31] RFC 2564 Application Management MIB May 1999

         ::= { applOpenFileEntry 3 }
 applOpenFileMode   OBJECT-TYPE
         SYNTAX     INTEGER { read(1),
                              write(2),
                              readWrite(3) }
         MAX-ACCESS read-only
         STATUS     current
         DESCRIPTION
            "This attribute reports the current mode of this file from
             the perspective of this running application element.
             These values have the following meanings:
                 read(1) - file opened for reading only
                 write(2) - file opened for writing only
                 readWrite(3) - file opened for read and write.
             These values correspond to the POSIX/ANSI C library
             function fopen() 'type' parameter, using the following
             mappings:
                 r -> read(1)
                 w -> write(2)
                 a -> write(2)
                 + -> readWrite(3)
           "
         ::= { applOpenFileEntry 4 }
  1. -
  2. -
  3. - applOpenConnectionTable - Open Connection Table
  4. -
  5. -
 applOpenConnectionTable OBJECT-TYPE
         SYNTAX          SEQUENCE OF ApplOpenConnectionEntry
         MAX-ACCESS      not-accessible
         STATUS          current
         DESCRIPTION
            "The applOpenConnectionTable provides information about
             open and listening connections from the perspective
             of a running application element or service instance.
             Entries in this table are indexed by applElmtOrSvc,
             applElmtOrSvcID, and by applOpenChannelIndex, which
             serves to uniquely identify each connection in the
             context of a service instance or running application

Kalbfleisch, et al. Standards Track [Page 32] RFC 2564 Application Management MIB May 1999

             element.
             For each row in this table, a corresponding row will
             exist in the applOpenChannel table.  For rows in the
             applOpenChannelTable which do not represent open or
             listening connections, no corresponding rows will exist
             in this table."
         ::= { applChannelGroup 3 }
 applOpenConnectionEntry OBJECT-TYPE
         SYNTAX          ApplOpenConnectionEntry
         MAX-ACCESS      not-accessible
         STATUS          current
         DESCRIPTION
            "An applOpenConnectionEntry indicates that a running
             application element or service instance has an open
             connection.  The entry has information describing that
             connection.
             In the case of a TCP transport, the element
             applOpenConnectionNearEndAddr and that row's
             applOpenConnectionFarEndAddr would correspond
             to a tcpConnEntry.  For a UDP transport, a
             similar relationship exists with respect to
             a udpEntry."
         INDEX           { applElmtOrSvc, applElmtOrSvcId,
                           applOpenChannelIndex }
         ::= { applOpenConnectionTable 1 }
 ApplOpenConnectionEntry  ::= SEQUENCE
         {
                 applOpenConnectionTransport     TDomain,
                 applOpenConnectionNearEndAddr   ApplTAddress,
                 applOpenConnectionNearEndpoint  SnmpAdminString,
                 applOpenConnectionFarEndAddr    ApplTAddress,
                 applOpenConnectionFarEndpoint   SnmpAdminString,
                 applOpenConnectionApplication   SnmpAdminString
         }
 applOpenConnectionTransport OBJECT-TYPE
         SYNTAX              TDomain
         MAX-ACCESS          read-only
         STATUS              current

Kalbfleisch, et al. Standards Track [Page 33] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "The applOpenConnectionTransport attribute identifies the
             transport protocol in use for this connection.  If it is
             not practical to determine the underlying transport, this
             attribute's value shall have a value of {0 0}."
         DEFVAL { zeroDotZero }
         ::= { applOpenConnectionEntry 1 }
 applOpenConnectionNearEndAddr OBJECT-TYPE
         SYNTAX                ApplTAddress
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applOpenConnectionNearEndAddr attribute reports the
             transport address and port information for the near end
             of this connection.
             If the value is not known, the value has a  length
             of zero."
         DEFVAL { "" }
         ::= { applOpenConnectionEntry 2 }
 applOpenConnectionNearEndpoint OBJECT-TYPE
         SYNTAX                 SnmpAdminString
         MAX-ACCESS             read-only
         STATUS                 current
         DESCRIPTION
            "The applOpenConnectionNearEndpoint attribute reports the
             fully-qualified domain name and port information for the
             near end of this connection.
             The format of this attribute for TCP and UDP-based
             protocols is the fully-qualified domain name immediately
             followed by a colon which is immediately followed by
             the decimal representation of the port number.
             If the value is not known, the value has a  length
             of zero."
         DEFVAL { "" }
         ::= { applOpenConnectionEntry 3 }
 applOpenConnectionFarEndAddr OBJECT-TYPE
         SYNTAX               ApplTAddress
         MAX-ACCESS           read-only
         STATUS               current

Kalbfleisch, et al. Standards Track [Page 34] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "The applOpenConnectionFarEndAddr attribute reports the
             transport address and port information for the far end
             of this connection.
             If not known, as in the case of a connectionless
             transport, the value of this attribute shall be a
             zero-length string."
         DEFVAL { "" }
         ::= { applOpenConnectionEntry 4 }
 applOpenConnectionFarEndpoint OBJECT-TYPE
         SYNTAX               SnmpAdminString
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "The applOpenConnectionFarEndpoint attribute reports
             the fully-qualified domain name and port information
             for the far end of this connection.
             The format of this attribute for TCP and UDP-based
             protocols is the fully-qualified domain name immediately
             followed by a colon which is immediately followed by
             the decimal representation of the port number.
             If not known, as in the case of a connectionless
             transport, the value of this attribute shall be a
             zero-length string."
         DEFVAL { "" }
         ::= { applOpenConnectionEntry 5 }
 applOpenConnectionApplication OBJECT-TYPE
         SYNTAX                SnmpAdminString
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applOpenConnectionApplication attribute identifies
             the application layer protocol in use.  If not known,
             the value of this attribute shall be a zero-length
             string.
             When possible, protocol names should be those used in
             the 'ASSIGNED NUMBERS' [13].  For example, an SMTP mail
             server would use 'SMTP'."
         DEFVAL { "" }
         ::= { applOpenConnectionEntry 6 }

Kalbfleisch, et al. Standards Track [Page 35] RFC 2564 Application Management MIB May 1999

  1. -
  2. -
  3. - applTransactionStreamTable - common
  4. - information for transaction stream monitoring
  5. -
  6. -
 applTransactionStreamTable OBJECT-TYPE
         SYNTAX             SEQUENCE OF ApplTransactionStreamEntry
         MAX-ACCESS         not-accessible
         STATUS             current
         DESCRIPTION
            "The applTransactionStreamTable contains common
             information for transaction statistic accumulation."
         ::= { applChannelGroup 4 }
 applTransactionStreamEntry OBJECT-TYPE
         SYNTAX             ApplTransactionStreamEntry
         MAX-ACCESS         not-accessible
         STATUS             current
         DESCRIPTION
            "An applTransactionStreamEntry contains information for
             a single transaction stream.  A transaction stream
             can be a network connection, file, or other source
             of transactions."
         INDEX           { applElmtOrSvc, applElmtOrSvcId,
                           applOpenChannelIndex }
         ::= { applTransactionStreamTable 1 }
 ApplTransactionStreamEntry ::= SEQUENCE {
         applTransactStreamDescr       SnmpAdminString,
         applTransactStreamUnitOfWork  SnmpAdminString,
         applTransactStreamInvokes     Counter64,
         applTransactStreamInvokesLow  Counter32,
         applTransactStreamInvCumTimes Counter32,
         applTransactStreamInvRspTimes Counter32,
         applTransactStreamPerforms    Counter64,
         applTransactStreamPerformsLow Counter32,
         applTransactStreamPrfCumTimes Counter32,
         applTransactStreamPrfRspTimes Counter32 }
 applTransactStreamDescr OBJECT-TYPE
         SYNTAX          SnmpAdminString
         MAX-ACCESS      read-only
         STATUS          current
         DESCRIPTION
            "The applTransactStreamDescr attribute provides a
             human-readable description of this transaction stream.

Kalbfleisch, et al. Standards Track [Page 36] RFC 2564 Application Management MIB May 1999

             If no descriptive information is available, this
             attribute's value shall be a zero-length string."
         DEFVAL { "" }
         ::= { applTransactionStreamEntry 1 }
 applTransactStreamUnitOfWork OBJECT-TYPE
         SYNTAX               SnmpAdminString
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "The applTransactStreamUnitOfWork attribute provides a
             human-readable definition of what the unit of work is
             for this transaction stream.
             If no descriptive information is available, this
             attribute's value shall be a zero-length string."
         DEFVAL { "" }
         ::= { applTransactionStreamEntry 2 }
 applTransactStreamInvokes OBJECT-TYPE
         SYNTAX            Counter64
         UNITS             "transactions"
         MAX-ACCESS        read-only
         STATUS            current
         DESCRIPTION
            "Cumulative count of requests / invocations issued.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 3 }
 applTransactStreamInvokesLow OBJECT-TYPE
         SYNTAX               Counter32
         UNITS                "transactions"
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "This counter corresponds to the low thirty-two
             bits of applTransactStreamInvokes.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 4 }

Kalbfleisch, et al. Standards Track [Page 37] RFC 2564 Application Management MIB May 1999

 applTransactStreamInvCumTimes OBJECT-TYPE
         SYNTAX                Counter32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applTransactStreamInvCumTimes attribute reports the
             cumulative sum of the lengths of the intervals measured
             between the transmission of requests and the receipt of
             (the first of) the corresponding response(s).
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 5 }
 applTransactStreamInvRspTimes OBJECT-TYPE
         SYNTAX                Counter32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applTransactStreamInvRspTimes attribute reports the
             cumulative sum of the lengths of the intervals measured
             between the receipt of the first and last of multiple
             responses to a request.
             For transaction streams which do not permit multiple
             responses to a single request, this attribute will be
             constant.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 6 }
 applTransactStreamPerforms OBJECT-TYPE
         SYNTAX             Counter64
         UNITS              "transactions"
         MAX-ACCESS         read-only
         STATUS             current
         DESCRIPTION
            "Cumulative count of transactions performed.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 7 }

Kalbfleisch, et al. Standards Track [Page 38] RFC 2564 Application Management MIB May 1999

 applTransactStreamPerformsLow OBJECT-TYPE
         SYNTAX                Counter32
         UNITS                 "transactions"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "This counter reports the low thirty-two bits of
             applTransactStreamPerforms.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 8 }
 applTransactStreamPrfCumTimes OBJECT-TYPE
         SYNTAX                Counter32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applTransactStreamPrfCumTimes attribute reports the
             cumulative sum of the interval lengths measured between
             receipt of requests and the transmission of the
             corresponding responses.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 9 }
 applTransactStreamPrfRspTimes OBJECT-TYPE
         SYNTAX                Counter32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "For each transaction performed, the elapsed time between
             when the first response is enqueued and when the last
             response is enqueued is added to this cumulative sum.
             For single-response protocols, the value of
             applTransactStreamPrfRspTimes will be constant.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactionStreamEntry 10 }

Kalbfleisch, et al. Standards Track [Page 39] RFC 2564 Application Management MIB May 1999

  1. -
  2. -
  3. - applTransactFlowTable
  4. -
  5. -
 applTransactFlowTable OBJECT-TYPE
         SYNTAX        SEQUENCE OF ApplTransactFlowEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "The applTransactFlowTable contains entries, organized by
             application instance or running application element,
             direction of flow, and type (request/response) for each
             open transaction stream.
             The simple model of a transaction used here looks like
             this:
                 invoker  |   Request     | performer
                          | - - - - - - > |
                          |               |
                          |   Response    |
                          | < - - - - - - |
                          |               |
             Since in some protocols it is possible for an entity
             to take on both the invoker and performer roles,
             information here is accumulated for transmitted and
             received requests, as well as for transmitted and
             received responses.  Counts are maintained for both
             transactions and bytes transferred."
         ::= { applChannelGroup 5 }
 applTransactFlowEntry OBJECT-TYPE
         SYNTAX        ApplTransactFlowEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "An applTransactFlowEntry reports transaction throughput
             information for requests or response in a particular
             direction (transmit / receive) for a transaction stream.
             Entries in this table correspond to those in the
             applTransactionStreamTable with identical values for the
             applElmtOrSvc, applElmtOrSvcId, and applOpenChannelIndex.
             For all counter objects in one of these entries,

Kalbfleisch, et al. Standards Track [Page 40] RFC 2564 Application Management MIB May 1999

             the corresponding (same value for applElmtOrSvc,
             applElmtOrSvcId, and applOpenChannelIndex)
             applOpenChannelOpenTime object serves as a discontinuity
             indicator.  "
         INDEX           { applElmtOrSvc,
                           applElmtOrSvcId,
                           applOpenChannelIndex,
                           applTransactFlowDirection,
                           applTransactFlowReqRsp }
         ::= { applTransactFlowTable 1 }
 ApplTransactFlowEntry ::= SEQUENCE {
                 applTransactFlowDirection INTEGER,
                 applTransactFlowReqRsp    INTEGER,
                 applTransactFlowTrans     Counter64,
                 applTransactFlowTransLow  Counter32,
                 applTransactFlowBytes     Counter64,
                 applTransactFlowBytesLow  Counter32,
                 applTransactFlowTime      DateAndTime }
 applTransactFlowDirection OBJECT-TYPE
         SYNTAX            INTEGER { transmit(1),
                                     receive(2) }
         MAX-ACCESS        not-accessible
         STATUS            current
         DESCRIPTION
             "The applTransactFlowDirection index serves to identify
              an entry as containing information pertaining to the
              transmit (1) or receive (2) flow of a transaction
              stream."
         ::= { applTransactFlowEntry 1 }
 applTransactFlowReqRsp OBJECT-TYPE
         SYNTAX         INTEGER { request(1),
                                  response(2) }
         MAX-ACCESS     not-accessible
         STATUS         current
         DESCRIPTION
            "The value of the applTransactFlowReqRsp index indicates
             whether this entry contains information on requests
             (1), or responses (2)."
         ::= { applTransactFlowEntry 2 }
 applTransactFlowTrans OBJECT-TYPE
         SYNTAX        Counter64
         UNITS         "transactions"
         MAX-ACCESS    read-only
         STATUS        current

Kalbfleisch, et al. Standards Track [Page 41] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
             "The applTransactFlowTrans attribute reports the number
              of request/response transactions (as indicated by
              the applTransactFlowReqRsp index) received/generated
              (as indicated by the applTransactFlowDirection index)
              that this service instance or running application
              element has processed for this transaction stream.
              Discontinuities in this counter can be detected
              by monitoring the corresponding instance of
              applOpenChannelOpenTime."
         ::= { applTransactFlowEntry 3 }
 applTransactFlowTransLow OBJECT-TYPE
         SYNTAX           Counter32
         UNITS            "transactions"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
             "This attribute corresponds to the low thirty-two
              bits of applTransactFlowTrans.
              Discontinuities in this counter can be detected
              by monitoring the corresponding instance of
              applOpenChannelOpenTime."
         ::= { applTransactFlowEntry 4 }
 applTransactFlowBytes OBJECT-TYPE
         SYNTAX        Counter64
         UNITS         "bytes"
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "The applTransactFlowBytes attribute reports the number
             of request/response (as indicated by the
             applTransactFlowReqRsp index) bytes received/generated
             (as indicated by the applTransactFlowDirection index)
             handled by this application element or service instance
             on this transaction stream.
             All application layer bytes are included in this count,
             including any application layer wrappers, headers, or
             other overhead.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactFlowEntry 5 }

Kalbfleisch, et al. Standards Track [Page 42] RFC 2564 Application Management MIB May 1999

 applTransactFlowBytesLow OBJECT-TYPE
         SYNTAX           Counter32
         UNITS            "bytes"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two
             bits of applTransactFlowBytes.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactFlowEntry 6 }
 applTransactFlowTime OBJECT-TYPE
         SYNTAX       DateAndTime
         MAX-ACCESS   read-only
         STATUS       current
         DESCRIPTION
            "The applTransactFlowTime attribute records the time of
             the processing (receipt or transmission as indicated
             by the applTransactFlowDirection index) by this
             running application element or service instance of
             the most recent request/response (as indicated by
             the applTransactFlowReqRsp index) on this transaction
             stream.
             If no requests/responses been received/transmitted by
             this entity over this transaction stream, the value
             of this attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applTransactFlowEntry 7 }
  1. -
  2. -
  3. - applTransactKindTable - transaction statistics broken down
  4. - according to the kinds of transactions in each direction
  5. - for a transaction stream.
  6. -
  7. -
 applTransactKindTable   OBJECT-TYPE
         SYNTAX SEQUENCE OF ApplTransactKindEntry
         MAX-ACCESS      not-accessible
         STATUS          current

Kalbfleisch, et al. Standards Track [Page 43] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "The applTransactKindTable provides transaction statistics
             broken down by kinds of transaction.  The definition of
             the kinds of transactions is specific to the application
             protocol in use, and may be documented in the form of an
             applicability statement.  "
         ::= { applChannelGroup 6 }
 applTransactKindEntry OBJECT-TYPE
         SYNTAX        ApplTransactKindEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "An applTransactKindEntry reports information for a
             specific service instance or running application
             element's use of a specific transaction stream in
             a particular direction in requests or responses
             (as indicated by the applTransactFlowReqRsp index)
             broken down by transaction kind, as indicated by the
             applTransactKind index.
             Discontinuities in any of the counters in an entry can
             be detected by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         INDEX           { applElmtOrSvc,
                           applElmtOrSvcId,
                           applOpenChannelIndex,
                           applTransactFlowDirection,
                           applTransactFlowReqRsp,
                           applTransactKind }
         ::= { applTransactKindTable 1 }
 ApplTransactKindEntry ::= SEQUENCE
         {
                 applTransactKind                SnmpAdminString,
                 applTransactKindTrans           Counter64,
                 applTransactKindTransLow        Counter32,
                 applTransactKindBytes           Counter64,
                 applTransactKindBytesLow        Counter32,
                 applTransactKindTime            DateAndTime
         }
 applTransactKind   OBJECT-TYPE
         SYNTAX     SnmpAdminString (SIZE (1 .. 32))
         MAX-ACCESS not-accessible
         STATUS     current
         DESCRIPTION

Kalbfleisch, et al. Standards Track [Page 44] RFC 2564 Application Management MIB May 1999

            "The applTransactKind index is the human-readable
             identifier for a particular transaction kind within
             the context of an application protocol.  The values
             to be used for a particular protocol may be identified
             in an applicability statement."
         ::= { applTransactKindEntry 1 }
 applTransactKindTrans OBJECT-TYPE
         SYNTAX        Counter64
         UNITS         "transactions"
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "The applTransactKindTrans attribute reports the number
             of request/response (as indicated by the
             applTransactFlowReqRsp index) transactions
             received/generated (as indicated by the
             applTransactFlowDirection index) handled by this
             application instance or application element on this
             transaction stream for this transaction kind.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactKindEntry 2 }
 applTransactKindTransLow OBJECT-TYPE
         SYNTAX           Counter32
         UNITS            "transactions"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "The applTransactKindTransLow attribute reports
             the low thirty-two bits of applTransactKindTrans.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactKindEntry 3 }
 applTransactKindBytes OBJECT-TYPE
         SYNTAX        Counter64
         UNITS         "bytes"
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "The applTransactKindBytes attribute reports the number
             of request/response (as indicated by the

Kalbfleisch, et al. Standards Track [Page 45] RFC 2564 Application Management MIB May 1999

             applTransactFlowReqRsp index) bytes received/generated
             (as indicated by the applTransactFlowDirection index)
             handled by this application element on this transaction
             stream for this transaction kind.
             All application layer bytes are included in this count,
             including any application layer wrappers, headers, or
             other overhead.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactKindEntry 4 }
 applTransactKindBytesLow OBJECT-TYPE
         SYNTAX           Counter32
         UNITS            "bytes"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "The applTransactKindBytesLow attribute corresponds
             to the low thirty-two bits of applTransactKindBytes.
             Discontinuities in this counter can be detected
             by monitoring the corresponding instance of
             applOpenChannelOpenTime."
         ::= { applTransactKindEntry 5 }
 applTransactKindTime OBJECT-TYPE
         SYNTAX       DateAndTime
         MAX-ACCESS   read-only
         STATUS       current
         DESCRIPTION
            "The applTransactKindTime attribute records the time of
             the processing (receipt or transmission as indicated
             by the applTransactFlowDirection index) by this
             running application element or service instance of
             the most recent request/response (as indicated by
             the applTransactFlowReqRsp index) of this kind of
             transaction on this transaction stream.
             If no requests/responses of this kind been
             received/transmitted by this running application element
             or service instance over this transaction stream, the
             value of this attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applTransactKindEntry 6 }

Kalbfleisch, et al. Standards Track [Page 46] RFC 2564 Application Management MIB May 1999

  1. -
  2. -
  3. - applPastChannelGroup - logged information on former channels.
  4. - These tables control the collection of channel history
  5. - information and represent the accumulated historical data.
  6. -
  7. -
 applPastChannelControlTable OBJECT-TYPE
         SYNTAX           SEQUENCE OF ApplPastChannelControlEntry
         MAX-ACCESS       not-accessible
         STATUS           current
         DESCRIPTION
            "The applPastChannelControlTable controls the
             accumulation of history information about channels
             from the perspective of service instances and running
             application elements.  Entries in this table are indexed
             by applElmtOrSvc and applElmtOrSvcId, giving control
             of channel history accumulation at the level of each
             service instance and running application element."
         ::= { applPastChannelGroup 1 }
 applPastChannelControlEntry OBJECT-TYPE
         SYNTAX           ApplPastChannelControlEntry
         MAX-ACCESS       not-accessible
         STATUS           current
         DESCRIPTION
            "An applPastChannelControlEntry provides the ability
             to control the retention of channel history information
             by service instances and running application elements."
         INDEX           { applElmtOrSvc, applElmtOrSvcId }
         ::= { applPastChannelControlTable 1 }
 ApplPastChannelControlEntry  ::= SEQUENCE
         {
                 applPastChannelControlCollect   INTEGER,
                 applPastChannelControlMaxRows   Unsigned32,
                 applPastChannelControlTimeLimit Unsigned32,
                 applPastChannelControlRemItems  Counter32
         }
 applPastChannelControlCollect OBJECT-TYPE
         SYNTAX             INTEGER { enabled (1),
                                      frozen (2),
                                      disabled (3) }
         MAX-ACCESS         read-write
         STATUS             current
         DESCRIPTION

Kalbfleisch, et al. Standards Track [Page 47] RFC 2564 Application Management MIB May 1999

            "When the value of applPastChannelControlCollect is
             'enabled', each time the corresponding running
             application element or service instance closes
             an open channel a new entry will be added to the
             applPastChannelTable.
             When the value of applPastChannelControlCollect
             is 'frozen', no new entries are added to the
             applPastChannelTable for this running application
             element or service instance, and old entries are not
             aged out.
             When the value of applPastChannelControlCollect
             is 'disabled', all entries are removed from
             applPastChannelTable for this running application or
             service instance, and no new entries are added."
         DEFVAL { enabled }
         ::= { applPastChannelControlEntry 1 }
 applPastChannelControlMaxRows OBJECT-TYPE
         SYNTAX             Unsigned32
         UNITS              "channel history entries"
         MAX-ACCESS         read-write
         STATUS             current
         DESCRIPTION
            "The maximum number of entries allowed in the
             applPastChannelTable for this running application element
             or service instance.  Once the number of rows for this
             running application element or service instance in the
             applPastChannelTable reaches this value, when new
             entries are to be added the management subsystem will
             make room for them by removing the oldest entries.
             Entries will be removed on the basis of oldest
             applPastChannelCloseTime value first."
         DEFVAL          { 500 }
         ::= { applPastChannelControlEntry 2 }
 applPastChannelControlTimeLimit OBJECT-TYPE
         SYNTAX               Unsigned32
         UNITS                "seconds"
         MAX-ACCESS           read-write
         STATUS               current
         DESCRIPTION
            "The maximum time in seconds which an entry for this
             running application element or service instance
             may exist in the applPastChannelTable before it
             is removed.  Any entry that is older than this value
             will be removed (aged out) from the table, unless the

Kalbfleisch, et al. Standards Track [Page 48] RFC 2564 Application Management MIB May 1999

             applPastChannelControlCollect is set to 'frozen'.
             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 applPastChannelControlMaxRows, or if the
             applPastChannelControlCollect is set to 'disabled'."
         DEFVAL          { 7200 }
         ::= { applPastChannelControlEntry 3 }
 applPastChannelControlRemItems OBJECT-TYPE
         SYNTAX              Counter32
         UNITS               "channel history entries"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "The applPastChannelControlRemItems attribute reports the
             number of applPastChannelControlTable entries for this
             running application element or service instance that
             were deleted in order to make room for new history
             entries.
             This count does NOT include entries deleted for the
             following reasons:
                 - the corresponding applPastChannelControlCollect
                   attribute has been set to 'disabled'
  1. the entry has been in the table longer that the

time limit indicated by the corresponding

                   applPastChannelControlTimeLimit.
           "
         ::= { applPastChannelControlEntry 4 }
  1. -
  2. -
  3. - applPastChannelTable - Table of former channels
  4. -
  5. -
 applPastChannelTable   OBJECT-TYPE
         SYNTAX         SEQUENCE OF ApplPastChannelEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "The applPastChannelTable provides history information
             about channels from the perspective of running
             application elements and service instances.

Kalbfleisch, et al. Standards Track [Page 49] RFC 2564 Application Management MIB May 1999

             Entries in this table are indexed by applElmtOrSvc,
             applElmtOrSvcId, and by applPastChannelIndex, which
             serves to uniquely identify each former channel in the
             context of a running application element or service
             instance.
             Note that the value of applPastChannelIndex is
             independent of the value applOpenChannelIndex had when
             this channel was open.
             Entries for closed channels for a given running
             application element or service instance can
             be added to this table only if its entry in the
             applPastChannelControlTable has the value 'enabled'
             for the attribute applPastChannelControlCollect.
             Entries for closed channels are removed under the
             following circumstances:
  1. the running application element or service

instance no longer exists

  1. the corresponding applPastChannelControlCollect

attribute has been set to 'disabled'

  1. the entry has been in the table longer that the

time limit indicated by the corresponding

                   applPastChannelControlTimeLimit and the value of
                   applPastChannelControlCollect is not 'frozen'
  1. this is the oldest entry for the running

application element or service instance in

                   question and the addition of a new element would
                   otherwise cause applPastChannelControlMaxRows to
                   be exceeded for this running application element
                   or service instance.
  1. a value of applPastChannelIndex has been re-used.

Note that under normal circumstances, this is

                   unlikely.
             Removal/replacement of an entry under the
             last two conditions causes the corresponding
             applPastChannelControlRemItems to be incremented."
         ::= { applPastChannelGroup 2 }

Kalbfleisch, et al. Standards Track [Page 50] RFC 2564 Application Management MIB May 1999

 applPastChannelEntry   OBJECT-TYPE
         SYNTAX         ApplPastChannelEntry
         MAX-ACCESS     not-accessible
         STATUS         current
         DESCRIPTION
           "An applPastChannelEntry indicates that a running
            application element or service instance once had an open
            channel, which is now closed.  The entry has information
            describing that channel."
         INDEX       { applElmtOrSvc, applElmtOrSvcId,
                       applPastChannelIndex }
         ::= { applPastChannelTable 1 }
 ApplPastChannelEntry  ::= SEQUENCE
         {
                 applPastChannelIndex           Unsigned32,
                 applPastChannelOpenTime        DateAndTime,
                 applPastChannelCloseTime       DateAndTime,
                 applPastChannelReadRequests    Unsigned64TC,
                 applPastChannelReadReqsLow     Unsigned32,
                 applPastChannelReadFailures    Unsigned32,
                 applPastChannelBytesRead       Unsigned64TC,
                 applPastChannelBytesReadLow    Unsigned32,
                 applPastChannelLastReadTime    DateAndTime,
                 applPastChannelWriteRequests   Unsigned64TC,
                 applPastChannelWriteReqsLow    Unsigned32,
                 applPastChannelWriteFailures   Unsigned32,
                 applPastChannelBytesWritten    Unsigned64TC,
                 applPastChannelBytesWritLow    Unsigned32,
                 applPastChannelLastWriteTime   DateAndTime
         }
 applPastChannelIndex      OBJECT-TYPE
         SYNTAX            Unsigned32 (1..'ffffffff'h)
         MAX-ACCESS        not-accessible
         STATUS            current
         DESCRIPTION
            "This attribute serves to uniquely identify this closed
             channel in the context of the running application
             element or service instance.  This attribute has no
             other semantics.
             Note that the value of applPastChannelIndex is
             independent of the value applOpenChannelIndex had when
             this channel was active.
             In issuing this index value, the implementation must
             avoid re-issuing an index value which has already been

Kalbfleisch, et al. Standards Track [Page 51] RFC 2564 Application Management MIB May 1999

             assigned to an entry which has not yet been deleted due
             to age or space considerations.
             The value zero is excluded from the set of permitted
             values for this index in order to permit other tables to
             possibly represent information that cannot be associated
             with a specific entry in this table.  "
         ::= { applPastChannelEntry 1 }
 applPastChannelOpenTime OBJECT-TYPE
         SYNTAX          DateAndTime
         MAX-ACCESS      read-only
         STATUS          current
         DESCRIPTION
            "This attribute records the time when this channel was
             originally opened.  Note that this information is quite
             different from applOpenChannelOpenTime, which is used
             for the detection of counter discontinuities."
         ::= { applPastChannelEntry 2 }
 applPastChannelCloseTime OBJECT-TYPE
         SYNTAX           DateAndTime
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "This attribute records the time when this channel
             was closed."
         ::= { applPastChannelEntry 3 }
 applPastChannelReadRequests OBJECT-TYPE
         SYNTAX              Unsigned64TC
         UNITS               "read requests"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute records the number of read requests for
             this channel made by this running application element or
             service instance.  All read requests for this channel by
             this running application element or service instance,
             regardless of completion status, are included in this
             count.  Read requests are counted in terms of system
             calls, rather than API calls."
         ::= { applPastChannelEntry 4 }

Kalbfleisch, et al. Standards Track [Page 52] RFC 2564 Application Management MIB May 1999

 applPastChannelReadReqsLow OBJECT-TYPE
         SYNTAX             Unsigned32
         UNITS              "read requests"
         MAX-ACCESS         read-only
         STATUS             current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two bits
             of applPastChannelReadRequests."
         ::= { applPastChannelEntry 5 }
 applPastChannelReadFailures OBJECT-TYPE
         SYNTAX              Unsigned32
         UNITS               "failed read requests"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute reports the number of failed read
             requests."
         ::= { applPastChannelEntry 6 }
 applPastChannelBytesRead OBJECT-TYPE
         SYNTAX           Unsigned64TC
         UNITS            "bytes"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "This attribute reports the number of bytes read from this
             channel by this running application element or service
             instance.  Only bytes successfully read are included in
             this count. "
         ::= { applPastChannelEntry 7 }
 applPastChannelBytesReadLow OBJECT-TYPE
         SYNTAX              Unsigned32
         UNITS               "bytes"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two bits
             of applPastChannelBytesRead."
         ::= { applPastChannelEntry 8 }
 applPastChannelLastReadTime OBJECT-TYPE
         SYNTAX              DateAndTime
         MAX-ACCESS          read-only
         STATUS              current

Kalbfleisch, et al. Standards Track [Page 53] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "This attribute reports the time of the most recent read
             request made by this running application element or
             service instance regardless of completion status, for
             this former channel.
             If no read requests have been made , the value of this
             attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applPastChannelEntry 9 }
 applPastChannelWriteRequests OBJECT-TYPE
         SYNTAX               Unsigned64TC
         UNITS                "write requests"
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "The applPastChannelWriteRequests attribute reports
             the number of write requests, regardless of completion
             status, made by this running application element or
             service instance for this former channel.
             Write requests are counted in terms of system calls,
             rather than API calls."
         ::= { applPastChannelEntry 10 }
 applPastChannelWriteReqsLow OBJECT-TYPE
         SYNTAX              Unsigned32
         UNITS               "write requests"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two
             bits of applPastChannelWriteRequests."
         ::= { applPastChannelEntry 11 }
 applPastChannelWriteFailures OBJECT-TYPE
         SYNTAX               Unsigned32
         UNITS                "failed write requests"
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "This attribute reports the number of failed write
             requests."
         ::= { applPastChannelEntry 12 }

Kalbfleisch, et al. Standards Track [Page 54] RFC 2564 Application Management MIB May 1999

 applPastChannelBytesWritten OBJECT-TYPE
         SYNTAX              Unsigned64TC
         UNITS               "bytes"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute reports the number of bytes written to
             this former channel by this running application element
             or service instance.  Only bytes successfully written
             (no errors reported by the API in use by the application)
             are included in this count."
         ::= { applPastChannelEntry 13 }
 applPastChannelBytesWritLow OBJECT-TYPE
         SYNTAX              Unsigned32
         UNITS               "bytes"
         MAX-ACCESS          read-only
         STATUS              current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two bits of
             applPastChannelBytesWritten."
         ::= { applPastChannelEntry 14 }
 applPastChannelLastWriteTime OBJECT-TYPE
         SYNTAX               DateAndTime
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "The applPastChannelLastWriteTime attribute reports
             the time of the most recent write request made by
             this running application element or service instance,
             regardless of completion status, for this former
             channel.
             If no write requests have been made the value of this
             attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applPastChannelEntry 15 }
  1. -
  2. -
  3. - applPastFileTable - information specific to former files
  4. -
  5. -

Kalbfleisch, et al. Standards Track [Page 55] RFC 2564 Application Management MIB May 1999

 applPastFileTable  OBJECT-TYPE
         SYNTAX     SEQUENCE OF ApplPastFileEntry
         MAX-ACCESS not-accessible
         STATUS     current
         DESCRIPTION
            "The applPastFileTable supplements the
             applPastChannelTable for entries corresponding to
             channels which were files.  The indexing structure is
             identical to applPastChannelTable.  An entry exists in
             the applPastFileTable only if there is a corresponding
             (same index values) entry in the applPastChannelTable
             and if the channel was a file.
             Entries for closed files are removed when the
             corresponding entries are removed from the
             applPastChannelTable."
         ::= { applPastChannelGroup 3 }
 applPastFileEntry   OBJECT-TYPE
         SYNTAX      ApplPastFileEntry
         MAX-ACCESS  not-accessible
         STATUS      current
         DESCRIPTION
           "An applPastFileEntry provides additional, file-specific
            information to complement the corresponding
            applPastChannelEntry for a channel which was a file."
         INDEX       { applElmtOrSvc, applElmtOrSvcId,
                       applPastChannelIndex }
         ::= { applPastFileTable 1 }
 ApplPastFileEntry ::= SEQUENCE
         {
                 applPastFileName                LongUtf8String,
                 applPastFileSizeHigh            Unsigned32,
                 applPastFileSizeLow             Unsigned32,
                 applPastFileMode                INTEGER
         }
 applPastFileName   OBJECT-TYPE
         SYNTAX     LongUtf8String
         MAX-ACCESS read-only
         STATUS     current
         DESCRIPTION
           "This attribute records the last known value of
            applOpenFileName before the channel was closed."
         ::= { applPastFileEntry 1 }

Kalbfleisch, et al. Standards Track [Page 56] RFC 2564 Application Management MIB May 1999

 applPastFileSizeHigh OBJECT-TYPE
         SYNTAX       Unsigned32
         UNITS        "2^32 byte blocks"
         MAX-ACCESS   read-only
         STATUS       current
         DESCRIPTION
           "This attribute records the value of applOpenFileSizeHigh
            at the time this channel was closed.
            For example, for a file with a total size of
            4,294,967,296 bytes, this attribute would have a value
            of 1; for a file with a total size of 4,294,967,295
            bytes this attribute's value would be 0."
         ::= { applPastFileEntry 2 }
 applPastFileSizeLow OBJECT-TYPE
         SYNTAX      Unsigned32
         UNITS       "bytes"
         MAX-ACCESS  read-only
         STATUS      current
         DESCRIPTION
            "This attribute records the value of applOpenFileSizeLow
             at the time this channel was closed.
             For example, for a file with a total size of
             4,294,967,296 bytes this attribute would have a value
             of 0; for a file with a total size of 4,294,967,295
             bytes this attribute's value would be 4,294,967,295."
         ::= { applPastFileEntry 3 }
 applPastFileMode   OBJECT-TYPE
         SYNTAX     INTEGER { read(1),
                              write(2),
                              readWrite(3) }
         MAX-ACCESS read-only
         STATUS     current
         DESCRIPTION
            "This attribute records the value of applOpenFileMode
             at the time this channel was closed.  "
         ::= { applPastFileEntry 4 }
  1. -
  2. -
  3. - applPastConTable - information specific to former connections
  4. -
  5. -

Kalbfleisch, et al. Standards Track [Page 57] RFC 2564 Application Management MIB May 1999

 applPastConTable OBJECT-TYPE
         SYNTAX    SEQUENCE OF ApplPastConEntry
         MAX-ACCESS not-accessible
         STATUS     current
         DESCRIPTION
            "The applPastConTable supplements the applPastChannelTable
             for entries corresponding to channels which were
             connections.  The indexing structure is identical
             to applPastChannelTable.  An entry exists in the
             applPastConTable only if there is a corresponding
             (same index values) entry in the applPastChannelTable
             and if the channel was a connection.
             Entries for closed connections are removed when
             the corresponding entries are removed from the
             applPastChannelTable."
         ::= { applPastChannelGroup 4 }
 applPastConEntry   OBJECT-TYPE
         SYNTAX      ApplPastConEntry
         MAX-ACCESS  not-accessible
         STATUS      current
         DESCRIPTION
           "An applPastConEntry provides additional,
            connection-specific information to complement the
            corresponding applPastChannelEntry for a channel which
            was a connection."
         INDEX       { applElmtOrSvc, applElmtOrSvcId,
                       applPastChannelIndex }
         ::= { applPastConTable 1 }
 ApplPastConEntry ::= SEQUENCE
         {
                 applPastConTransport       TDomain,
                 applPastConNearEndAddr     ApplTAddress,
                 applPastConNearEndpoint    SnmpAdminString,
                 applPastConFarEndAddr      ApplTAddress,
                 applPastConFarEndpoint     SnmpAdminString,
                 applPastConApplication     SnmpAdminString
         }
 applPastConTransport OBJECT-TYPE
         SYNTAX       TDomain
         MAX-ACCESS   read-only
         STATUS       current

Kalbfleisch, et al. Standards Track [Page 58] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "The applPastConTransport attribute identifies the
             transport protocol that was in use for this former
             connection.  If the transport protocol could not be
             determined, the value { 0 0 } shall be used."
         DEFVAL { zeroDotZero }
         ::= { applPastConEntry 1 }
 applPastConNearEndAddr OBJECT-TYPE
         SYNTAX         ApplTAddress
         MAX-ACCESS     read-only
         STATUS         current
         DESCRIPTION
            "The applPastConNearEndAddr attribute reports the
             transport address and port information for the near
             end of this former connection.
             If the information could not be determined, the value
             shall be a zero-length string."
         DEFVAL { "" }
         ::= { applPastConEntry 2 }
 applPastConNearEndpoint OBJECT-TYPE
         SYNTAX          SnmpAdminString
         MAX-ACCESS      read-only
         STATUS          current
         DESCRIPTION
            "The applPastConNearEndpoint attribute reports the
             fully-qualified domain name and port information for the
             near end of this former connection.
             The format of this attribute for TCP and UDP-based
             protocols is the fully-qualified domain name immediately
             followed by a colon which is immediately followed by
             the decimal representation of the port number.
             If the information could not be determined, the value
             shall be a zero-length string."
         DEFVAL { "" }
         ::= { applPastConEntry 3 }
 applPastConFarEndAddr OBJECT-TYPE
         SYNTAX        ApplTAddress
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "The applPastConFarEnd attribute reports the transport
             address and port information for the far end of this

Kalbfleisch, et al. Standards Track [Page 59] RFC 2564 Application Management MIB May 1999

             former connection.
             If not known, as in the case of a connectionless
             transport, the value of this attribute shall be a
             zero-length string."
         DEFVAL { "" }
         ::= { applPastConEntry 4 }
 applPastConFarEndpoint OBJECT-TYPE
         SYNTAX        SnmpAdminString
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "The applPastConFarEndpoint attribute reports the
             transport address and port information for the far
             end of this former connection.
             The format of this attribute for TCP and UDP-based
             protocols is the fully-qualified domain name immediately
             followed by a colon which is immediately followed by
             the decimal representation of the port number.
             If not known, as in the case of a connectionless
             transport, the value of this attribute shall be a
             zero-length string."
         DEFVAL { "" }
         ::= { applPastConEntry 5 }
 applPastConApplication OBJECT-TYPE
         SYNTAX         SnmpAdminString
         MAX-ACCESS     read-only
         STATUS         current
         DESCRIPTION
            "The applPastConApplication attribute identifies the
             application layer protocol that was in use.  Where
             possible, the values defined in [13] shall be used.
             If not known, the value of this attribute shall be a
             zero-length string."
         DEFVAL { "" }
         ::= { applPastConEntry 6 }
  1. -
  2. -
  3. - applPastTransStreamTable - historical
  4. - information for transaction stream monitoring
  5. -
  6. -

Kalbfleisch, et al. Standards Track [Page 60] RFC 2564 Application Management MIB May 1999

 applPastTransStreamTable OBJECT-TYPE
         SYNTAX             SEQUENCE OF ApplPastTransStreamEntry
         MAX-ACCESS         not-accessible
         STATUS             current
         DESCRIPTION
            "The applPastTransStreamTable contains common
             information for historical transaction statistics."
         ::= { applPastChannelGroup 5 }
 applPastTransStreamEntry OBJECT-TYPE
         SYNTAX             ApplPastTransStreamEntry
         MAX-ACCESS         not-accessible
         STATUS             current
         DESCRIPTION
            "An applPastTransStreamEntry contains information for
             a single former transaction stream.  A transaction
             stream could have been a network connection, file, or
             other source of transactions."
         INDEX           { applElmtOrSvc, applElmtOrSvcId,
                           applPastChannelIndex }
         ::= { applPastTransStreamTable 1 }
 ApplPastTransStreamEntry ::= SEQUENCE {
         applPastTransStreamDescr        SnmpAdminString,
         applPastTransStreamUnitOfWork   SnmpAdminString,
         applPastTransStreamInvokes      Unsigned64TC,
         applPastTransStreamInvokesLow   Unsigned32,
         applPastTransStreamInvCumTimes  Unsigned32,
         applPastTransStreamInvRspTimes  Unsigned32,
         applPastTransStreamPerforms     Unsigned64TC,
         applPastTransStreamPerformsLow  Unsigned32,
         applPastTransStreamPrfCumTimes  Unsigned32,
         applPastTransStreamPrfRspTimes  Unsigned32 }
 applPastTransStreamDescr OBJECT-TYPE
         SYNTAX          SnmpAdminString
         MAX-ACCESS      read-only
         STATUS          current
         DESCRIPTION
            "The applPastTransStreamDescr attribute provides a
             human-readable description of this transaction stream.
             If no descriptive information is available, this
             attribute's value shall be a zero-length string."
         DEFVAL { "" }
         ::= { applPastTransStreamEntry 1 }

Kalbfleisch, et al. Standards Track [Page 61] RFC 2564 Application Management MIB May 1999

 applPastTransStreamUnitOfWork OBJECT-TYPE
         SYNTAX               SnmpAdminString
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "The applPastTransStreamUnitOfWork attribute provides a
             human-readable definition of what the unit of work is
             for this transaction stream.
             If no descriptive information is available, this
             attribute's value shall be a zero-length string."
         DEFVAL { "" }
         ::= { applPastTransStreamEntry 2 }
 applPastTransStreamInvokes OBJECT-TYPE
         SYNTAX            Unsigned64TC
         UNITS             "transactions"
         MAX-ACCESS        read-only
         STATUS            current
         DESCRIPTION
            "Cumulative count of requests / invocations issued
             for this transaction stream when it was active."
         ::= { applPastTransStreamEntry 3 }
 applPastTransStreamInvokesLow OBJECT-TYPE
         SYNTAX               Unsigned32
         UNITS                "transactions"
         MAX-ACCESS           read-only
         STATUS               current
         DESCRIPTION
            "This object corresponds to the low thirty-two
             bits of applPastTransStreamInvokes."
         ::= { applPastTransStreamEntry 4 }
 applPastTransStreamInvCumTimes OBJECT-TYPE
         SYNTAX                Unsigned32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applPastTransStreamInvCumTimes attribute reports the
             cumulative sum of the lengths of the intervals times
             measured between the transmission of requests and the
             receipt of (the first of) the corresponding response(s)."
         ::= { applPastTransStreamEntry 5 }

Kalbfleisch, et al. Standards Track [Page 62] RFC 2564 Application Management MIB May 1999

 applPastTransStreamInvRspTimes OBJECT-TYPE
         SYNTAX                Unsigned32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applPastTransStreamInvRspTimes attribute reports the
             cumulative sum of the lengths of the intervals measured
             between the receipt of the first and last of multiple
             responses to a request.
             For transaction streams which do not permit multiple
             responses to a single request, this attribute will be
             zero."
         ::= { applPastTransStreamEntry 6 }
 applPastTransStreamPerforms OBJECT-TYPE
         SYNTAX             Unsigned64TC
         UNITS              "transactions"
         MAX-ACCESS         read-only
         STATUS             current
         DESCRIPTION
            "Total number of transactions performed."
         ::= { applPastTransStreamEntry 7 }
 applPastTransStreamPerformsLow OBJECT-TYPE
         SYNTAX                Unsigned32
         UNITS                 "transactions"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "This objecy reports the low thirty-two bits of
             applPastTransStreamPerforms."
         ::= { applPastTransStreamEntry 8 }
 applPastTransStreamPrfCumTimes OBJECT-TYPE
         SYNTAX                Unsigned32
         UNITS                 "milliseconds"
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applPastTransStreamPrfCumTimes attribute reports the
             cumulative sum of the lengths of the intervals measured
             between receipt of requests and the transmission of the
             corresponding responses."
         ::= { applPastTransStreamEntry 9 }

Kalbfleisch, et al. Standards Track [Page 63] RFC 2564 Application Management MIB May 1999

 applPastTransStreamPrfRspTimes OBJECT-TYPE
         SYNTAX                 Unsigned32
         UNITS                  "milliseconds"
         MAX-ACCESS             read-only
         STATUS                 current
         DESCRIPTION
            "For each transaction performed, the elapsed time between
             when the first response is enqueued and when the last
             response is enqueued is added to this cumulative sum.
             For single-response protocols, the value of
             applPastTransStreamPrfRspTimes will be zero."
         ::= { applPastTransStreamEntry 10 }
  1. -
  2. -
  3. - applPastTransFlowTable
  4. -
  5. -
 applPastTransFlowTable OBJECT-TYPE
         SYNTAX        SEQUENCE OF ApplPastTransFlowEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "The applPastTransFlowTable contains entries, organized by
             application instance or running application element,
             direction of flow, and type (request/response) for each
             former transaction stream.
             The simple model of a transaction used here looks like
             this:
                 invoker  |   Request     | performer
                          | - - - - - - > |
                          |               |
                          |   Response    |
                          | < - - - - - - |
                          |               |
             Since in some protocols it is possible for an entity
             to take on both the invoker and performer roles,
             information here is accumulated for transmitted and
             received requests, as well as for transmitted and
             received responses.  Counts are maintained for both
             transactions and bytes transferred."
         ::= { applPastChannelGroup 6 }

Kalbfleisch, et al. Standards Track [Page 64] RFC 2564 Application Management MIB May 1999

 applPastTransFlowEntry OBJECT-TYPE
         SYNTAX        ApplPastTransFlowEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "An applPastTransFlowEntry records transaction throughput
             information for requests or response in a particular
             direction (transmit / receive) for a transaction stream.
             Entries in this table correspond to those in the
             applPastTransStreamTable with identical values
             for the applElmtOrSvc, applElmtOrSvcId, and the
             applPastChannelIndex."
         INDEX           { applElmtOrSvc,
                           applElmtOrSvcId,
                           applPastChannelIndex,
                           applPastTransFlowDirection,
                           applPastTransFlowReqRsp }
         ::= { applPastTransFlowTable 1 }
 ApplPastTransFlowEntry ::= SEQUENCE {
                 applPastTransFlowDirection INTEGER,
                 applPastTransFlowReqRsp    INTEGER,
                 applPastTransFlowTrans     Unsigned64TC,
                 applPastTransFlowTransLow  Unsigned32,
                 applPastTransFlowBytes     Unsigned64TC,
                 applPastTransFlowBytesLow  Unsigned32,
                 applPastTransFlowTime      DateAndTime }
 applPastTransFlowDirection OBJECT-TYPE
         SYNTAX             INTEGER { transmit(1),
                                      receive(2) }
         MAX-ACCESS         not-accessible
         STATUS             current
         DESCRIPTION
             "The applPastTransFlowDirection index serves
              to identify an entry as containing information
              pertaining to the transmit (1) or receive (2) flow
              of a past transaction stream.  This index corresponds
              to applTransactFlowDirection."
         ::= { applPastTransFlowEntry 1 }
 applPastTransFlowReqRsp OBJECT-TYPE
         SYNTAX          INTEGER { request(1),
                                   response(2) }
         MAX-ACCESS      not-accessible
         STATUS          current
         DESCRIPTION

Kalbfleisch, et al. Standards Track [Page 65] RFC 2564 Application Management MIB May 1999

            "The value of the applPastTransFlowReqRsp index indicates
             whether this entry contains information on requests
             (1), or responses (2).  This index corresponds to
             applTransactFlowReqRsp."
         ::= { applPastTransFlowEntry 2 }
 applPastTransFlowTrans OBJECT-TYPE
         SYNTAX        Unsigned64TC
         UNITS         "transactions"
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
             "The applPastTransFlowTrans attribute reports the number
              of request/response (as indicated by the
              applPastTransFlowReqRsp index) transactions
              received/generated (as indicated by the
              applPastTransFlowDirection index) handled on this
              transaction stream."
         ::= { applPastTransFlowEntry 3 }
 applPastTransFlowTransLow OBJECT-TYPE
         SYNTAX           Unsigned32
         UNITS            "transactions"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
             "This attribute corresponds to the low thirty-two
              bits of applPastTransFlowTrans."
         ::= { applPastTransFlowEntry 4 }
 applPastTransFlowBytes OBJECT-TYPE
         SYNTAX        Unsigned64TC
         UNITS         "bytes"
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "The applPastTransFlowBytes attribute reports the number
             of request/response (as indicated by the
             applPastTransFlowReqRsp index) bytes received/generated
             (as indicated by the applPastTransFlowDirection index)
             handled on this transaction stream.
             All application layer bytes are included in this count,
             including any application layer wrappers, headers, or
             other overhead."
         ::= { applPastTransFlowEntry 5 }

Kalbfleisch, et al. Standards Track [Page 66] RFC 2564 Application Management MIB May 1999

 applPastTransFlowBytesLow OBJECT-TYPE
         SYNTAX           Unsigned32
         UNITS            "bytes"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "This attribute corresponds to the low thirty-two
             bits of applPastTransFlowBytes."
         ::= { applPastTransFlowEntry 6 }
 applPastTransFlowTime OBJECT-TYPE
         SYNTAX       DateAndTime
         MAX-ACCESS   read-only
         STATUS       current
         DESCRIPTION
            "The applPastTransFlowTime attribute records the time of
             the processing (receipt or transmission as
             indicated by the applPastTransFlowDirection index)
             of the last request/response (as indicated by the
             applPastTransFlowReqRsp index) on this transaction
             stream.
             If no requests/responses been received/transmitted by
             this entity over this transaction stream, the value
             of this attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applPastTransFlowEntry 7 }
  1. -
  2. -
  3. - applPastTransKindTable - transaction statistics broken down
  4. - according to the kinds of transactions in each direction
  5. - for a transaction stream.
  6. -
  7. -
 applPastTransKindTable   OBJECT-TYPE
         SYNTAX SEQUENCE OF ApplPastTransKindEntry
         MAX-ACCESS      not-accessible
         STATUS          current
         DESCRIPTION
            "The applPastTransKindTable provides transaction
             statistics broken down by kinds of transaction.
             The definition of the kinds of transactions is
             specific to the application protocol in use, and may be
             documented in the form of an applicability statement.  "
         ::= { applPastChannelGroup 7 }

Kalbfleisch, et al. Standards Track [Page 67] RFC 2564 Application Management MIB May 1999

 applPastTransKindEntry OBJECT-TYPE
         SYNTAX        ApplPastTransKindEntry
         MAX-ACCESS    not-accessible
         STATUS        current
         DESCRIPTION
            "An applPastTransKindEntry reports historical data for a
             specific service instance or running application
             element's use of a specific transaction stream in
             a particular direction in requests or responses
             (as indicated by the applPastTransFlowReqRsp index)
             broken down by transaction kind, as indicated by the
             applPastTransKind index."
         INDEX           { applElmtOrSvc,
                           applElmtOrSvcId,
                           applPastChannelIndex,
                           applPastTransFlowDirection,
                           applPastTransFlowReqRsp,
                           applPastTransKind }
         ::= { applPastTransKindTable 1 }
 ApplPastTransKindEntry ::= SEQUENCE
         {
                 applPastTransKind                SnmpAdminString,
                 applPastTransKindTrans           Unsigned64TC,
                 applPastTransKindTransLow        Unsigned32,
                 applPastTransKindBytes           Unsigned64TC,
                 applPastTransKindBytesLow        Unsigned32,
                 applPastTransKindTime            DateAndTime
         }
 applPastTransKind   OBJECT-TYPE
         SYNTAX      SnmpAdminString (SIZE (1 .. 32))
         MAX-ACCESS  not-accessible
         STATUS      current
         DESCRIPTION
            "The applPastTransKind index is the human-readable
             identifier for a particular transaction kind within
             the context of an application protocol.  The values
             to be used for a particular protocol may be identified
             in an applicability statement.  This index corresponds
             to applTransactKind."
         ::= { applPastTransKindEntry 1 }
 applPastTransKindTrans OBJECT-TYPE
         SYNTAX        Unsigned64TC
         UNITS         "transactions"
         MAX-ACCESS    read-only
         STATUS        current

Kalbfleisch, et al. Standards Track [Page 68] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "For this transaction stream, this attribute records
             the total number of transactions of the type
             identified by the indexes.  The type is characterized
             according to the receive/transmit direction
             (applPastTransFlowDirecton), whether it was a request
             or a response (applPastTransFlowReqRsp), and the
             protocol-specific transaction kind (applPastTransKind).
             stream for this transaction kind."
         ::= { applPastTransKindEntry 2 }
 applPastTransKindTransLow OBJECT-TYPE
         SYNTAX           Unsigned32
         UNITS            "transactions"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "The applPastTransKindTransLow attribute reports
             the low thirty-two bits of applPastTransKindTrans."
         ::= { applPastTransKindEntry 3 }
 applPastTransKindBytes OBJECT-TYPE
         SYNTAX        Unsigned64TC
         UNITS         "bytes"
         MAX-ACCESS    read-only
         STATUS        current
         DESCRIPTION
            "For this transaction stream and transaction kind, the
             applPastTransKindBytes attribute reports the number
             of bytes received or generated (as indicated by
             the applPastTransFlowDirection index) in requests or
             responses (as indicated by the applPastTransFlowReqRsp
             index).
             All application layer bytes are included in this count,
             including any application layer wrappers, headers, or
             other overhead."
         ::= { applPastTransKindEntry 4 }
 applPastTransKindBytesLow OBJECT-TYPE
         SYNTAX           Unsigned32
         UNITS            "bytes"
         MAX-ACCESS       read-only
         STATUS           current
         DESCRIPTION
            "The applPastTransKindBytesLow attribute corresponds
             to the low thirty-two bits of applPastTransKindBytes."
         ::= { applPastTransKindEntry 5 }

Kalbfleisch, et al. Standards Track [Page 69] RFC 2564 Application Management MIB May 1999

 applPastTransKindTime OBJECT-TYPE
         SYNTAX       DateAndTime
         MAX-ACCESS   read-only
         STATUS       current
         DESCRIPTION
            "The applPastTransKindTime attribute records the time of
             the processing (receipt or transmission as
             indicated by the applPastTransFlowDirection index)
             of the last request/response (as indicated by the
             applPastTransFlowReqRsp index) of this kind of
             transaction on this transaction stream.
             If no requests/responses of this kind were
             received/transmitted over this transaction stream, the
             value of this attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applPastTransKindEntry 6 }
  1. -
  2. -
  3. - applElmtRunControlGroup - monitor and control running
  4. - application elements
  5. -
  6. -
 applElmtRunStatusTable OBJECT-TYPE
         SYNTAX         SEQUENCE OF ApplElmtRunStatusEntry
         MAX-ACCESS     not-accessible
         STATUS         current
         DESCRIPTION
            "This table provides information on running application
             elements, complementing information available in the
             correspondingly indexed sysApplElmtRunTable [31]."
         ::= { applElmtRunControlGroup 1 }
 applElmtRunStatusEntry OBJECT-TYPE
         SYNTAX         ApplElmtRunStatusEntry
         MAX-ACCESS     not-accessible
         STATUS         current
         DESCRIPTION
           "An applElmtRunStatusEntry contains information to support
            the control and monitoring of a single running application
            element."
         INDEX { sysApplElmtRunIndex }
         ::= { applElmtRunStatusTable 1 }

Kalbfleisch, et al. Standards Track [Page 70] RFC 2564 Application Management MIB May 1999

 ApplElmtRunStatusEntry ::= SEQUENCE {
         applElmtRunStatusSuspended              TruthValue,
         applElmtRunStatusHeapUsage              Unsigned32,
         applElmtRunStatusOpenConnections        Unsigned32,
         applElmtRunStatusOpenFiles              Gauge32,
         applElmtRunStatusLastErrorMsg           SnmpAdminString,
         applElmtRunStatusLastErrorTime          DateAndTime }
 applElmtRunStatusSuspended OBJECT-TYPE
         SYNTAX             TruthValue
         MAX-ACCESS         read-only
         STATUS             current
         DESCRIPTION
            "The applElmtRunStatusSuspended attribute reports
             whether processing by this running application element
             has been suspended, whether by management request or by
             other means."
         ::= { applElmtRunStatusEntry 1 }
 applElmtRunStatusHeapUsage OBJECT-TYPE
         SYNTAX             Unsigned32
         UNITS              "bytes"
         MAX-ACCESS         read-only
         STATUS             current
         DESCRIPTION
            "The applElmtRunStatusHeapUsage reports the current
             approximate heap usage by this running application
             element."
         ::= { applElmtRunStatusEntry 2 }
 applElmtRunStatusOpenConnections OBJECT-TYPE
         SYNTAX                   Unsigned32
         UNITS                    "connections"
         MAX-ACCESS               read-only
         STATUS                   current
         DESCRIPTION
            "The applElmtRunStatusOpenConnections attribute reports
             the current number of open connections in use by this
             running application element."
         ::= { applElmtRunStatusEntry 3 }
 applElmtRunStatusOpenFiles OBJECT-TYPE
         SYNTAX             Gauge32
         UNITS              "files"
         MAX-ACCESS         read-only
         STATUS             current
         DESCRIPTION
            "The applElmtRunStatusOpenFiles attribute reports the

Kalbfleisch, et al. Standards Track [Page 71] RFC 2564 Application Management MIB May 1999

             current number of open files in use by this running
             application element."
         ::= { applElmtRunStatusEntry 4 }
 applElmtRunStatusLastErrorMsg OBJECT-TYPE
         SYNTAX                SnmpAdminString
         MAX-ACCESS            read-only
         STATUS                current
         DESCRIPTION
            "The applElmtRunStatusLastErrorMessage attribute reports
             the most recent error message (typically written to
             stderr or a system error logging facility) from this
             running application element.  If no such message has yet
             been generated, the value of this attribute shall be a
             zero-length string."
         DEFVAL { "" }
         ::= { applElmtRunStatusEntry 5 }
 applElmtRunStatusLastErrorTime OBJECT-TYPE
         SYNTAX                 DateAndTime
         MAX-ACCESS             read-only
         STATUS                 current
         DESCRIPTION
            "The applElmtRunStatusLastErrorTime attribute reports the
             time of the most recent error message in
             applElmtRunStatusLastErrorMsg.
             If no such message has yet been generated, the value
             of this attribute shall be '0000000000000000'H "
         DEFVAL { '0000000000000000'H }
         ::= { applElmtRunStatusEntry 6 }
  1. -
  2. -
  3. - applElmtRunControlTable - control running application
  4. - elements
  5. -
  6. -
 applElmtRunControlTable OBJECT-TYPE
         SYNTAX          SEQUENCE OF ApplElmtRunControlEntry
         MAX-ACCESS      not-accessible
         STATUS          current

Kalbfleisch, et al. Standards Track [Page 72] RFC 2564 Application Management MIB May 1999

         DESCRIPTION
            "This table provides the ability to control application
             elements, complementing information available in the
             correspondingly indexed sysApplElmtRunTable [31]."
         ::= { applElmtRunControlGroup 2 }
 applElmtRunControlEntry OBJECT-TYPE
         SYNTAX          ApplElmtRunControlEntry
         MAX-ACCESS      not-accessible
         STATUS          current
         DESCRIPTION
            "An applElmtRunControlEntry contains information to
            support the control of a single running application
            element."
         INDEX { sysApplElmtRunIndex }
         ::= { applElmtRunControlTable 1 }
 ApplElmtRunControlEntry ::= SEQUENCE {
                 applElmtRunControlSuspend       TruthValue,
                 applElmtRunControlReconfigure   TestAndIncr,
                 applElmtRunControlTerminate     TruthValue }
 applElmtRunControlSuspend OBJECT-TYPE
         SYNTAX            TruthValue
         MAX-ACCESS        read-write
         STATUS            current
         DESCRIPTION
            "Setting this variable to 'true' requests the suspension
             of processing by this running application element.
             Setting this variable to 'false' requests that processing
             be resumed.  The effect, if any, will be reported by the
             applElmtRunStatusSuspended attribute."
         DEFVAL { false }
         ::= { applElmtRunControlEntry 1 }
 applElmtRunControlReconfigure OBJECT-TYPE
         SYNTAX                TestAndIncr
         MAX-ACCESS            read-write
         STATUS                current
         DESCRIPTION
            "Changing the value of this variable requests that the
             running application element re-load its configuration
             (like SIGHUP for many UNIX-based daemons).
             Note that completion of a SET on this object only implies
             that configuration reload was initiated, not necessarily
             that the reload has been completed."
         ::= { applElmtRunControlEntry 2 }

Kalbfleisch, et al. Standards Track [Page 73] RFC 2564 Application Management MIB May 1999

 applElmtRunControlTerminate OBJECT-TYPE
         SYNTAX              TruthValue
         MAX-ACCESS          read-write
         STATUS              current
         DESCRIPTION
            "Setting the value of applElmtRunControlTerminate to
             'true' requests that the running application element
             terminate processing and exit in an orderly manner.
             This is a 'polite' shutdown request.
             When read, this object's value will be 'false' except
             when orderly termination is in progress.
             Note that completion of a SET on this object only implies
             that termination was initiated, not necessarily that the
             termination has been completed."
         DEFVAL { false }
         ::= { applElmtRunControlEntry 3 }
  1. -
  2. -
  3. - Conformance requirements
  4. -
  5. -
 applicationMibGroups OBJECT IDENTIFIER ::=
                         { applicationMibConformance 1}
 applicationMonitorGroup OBJECT-GROUP
     OBJECTS { applSrvInstQual,
               applSrvName,
               applSrvIndex,
               applSrvInstance,
               applOpenChannelOpenTime,
               applOpenChannelReadRequestsLow,
               applOpenChannelReadFailures,
               applOpenChannelBytesReadLow,
               applOpenChannelLastReadTime,
               applOpenChannelWriteRequestsLow,
               applOpenChannelWriteFailures,
               applOpenChannelBytesWrittenLow,
               applOpenChannelLastWriteTime,
               applOpenFileName,
               applOpenFileSizeHigh,
               applOpenFileSizeLow,
               applOpenFileMode,
               applOpenConnectionTransport,

Kalbfleisch, et al. Standards Track [Page 74] RFC 2564 Application Management MIB May 1999

               applOpenConnectionNearEndAddr,
               applOpenConnectionNearEndpoint,
               applOpenConnectionFarEndAddr,
               applOpenConnectionFarEndpoint,
               applOpenConnectionApplication }
     STATUS current
     DESCRIPTION
         "This group represents the basic capabilities of this MIB."
     ::= { applicationMibGroups 1 }
 applicationFastMonitorGroup OBJECT-GROUP
     OBJECTS { applOpenChannelReadRequests,
               applOpenChannelBytesRead,
               applOpenChannelWriteRequests,
               applOpenChannelBytesWritten }
     STATUS current
     DESCRIPTION
         "This group comprises 64-bit counters mandatory in
          high-throughput environments, where 32-bit counters
          could wrap in less than an hour."
     ::= { applicationMibGroups 2 }
 applicationTransactGroup OBJECT-GROUP
     OBJECTS { applTransactStreamDescr,
               applTransactStreamUnitOfWork,
               applTransactStreamInvokesLow,
               applTransactStreamInvCumTimes,
               applTransactStreamInvRspTimes,
               applTransactStreamPerformsLow,
               applTransactStreamPrfCumTimes,
               applTransactStreamPrfRspTimes,
               applTransactFlowTransLow,
               applTransactFlowBytesLow,
               applTransactFlowTime,
               applTransactKindTransLow,
               applTransactKindBytesLow,
               applTransactKindTime }
     STATUS current
     DESCRIPTION
         "This group comprises objects appropriate from monitoring
          transaction-structured flows."
     ::= { applicationMibGroups 3 }
 applicationFastTransactGroup OBJECT-GROUP
     OBJECTS { applTransactStreamInvokes,
               applTransactStreamPerforms,
               applTransactFlowTrans,
               applTransactFlowBytes,

Kalbfleisch, et al. Standards Track [Page 75] RFC 2564 Application Management MIB May 1999

               applTransactKindTrans,
               applTransactKindBytes }
     STATUS current
     DESCRIPTION
         "This group comprises 64-bit transaction counters required in
          high-throughput environments, where 32-bit counters could
          wrap in less than an hour."
     ::= { applicationMibGroups 4 }
 applicationHistoryGroup OBJECT-GROUP
     OBJECTS { applPastChannelControlCollect,
               applPastChannelControlMaxRows,
               applPastChannelControlTimeLimit,
               applPastChannelControlRemItems,
               applPastChannelOpenTime,
               applPastChannelCloseTime,
               applPastChannelReadReqsLow,
               applPastChannelReadFailures,
               applPastChannelBytesReadLow,
               applPastChannelLastReadTime,
               applPastChannelWriteReqsLow,
               applPastChannelWriteFailures,
               applPastChannelBytesWritLow,
               applPastChannelLastWriteTime,
               applPastFileName,
               applPastFileSizeHigh,
               applPastFileSizeLow,
               applPastFileMode,
               applPastConTransport,
               applPastConNearEndAddr,
               applPastConNearEndpoint,
               applPastConFarEndAddr,
               applPastConFarEndpoint,
               applPastConApplication}
     STATUS current
     DESCRIPTION
         "This group models basic historical data."
     ::= { applicationMibGroups 5 }
 applicationFastHistoryGroup OBJECT-GROUP
     OBJECTS { applPastChannelReadRequests,
               applPastChannelBytesRead,
               applPastChannelWriteRequests,
               applPastChannelBytesWritten}
     STATUS current

Kalbfleisch, et al. Standards Track [Page 76] RFC 2564 Application Management MIB May 1999

     DESCRIPTION
         "This group comprises additional 64-bit objects required
          for recording historical data in high-volume environments,
          where a 32-bit integer would be insufficient."
     ::= { applicationMibGroups 6 }
 applicationTransHistoryGroup OBJECT-GROUP
     OBJECTS { applPastTransStreamDescr,
               applPastTransStreamUnitOfWork,
               applPastTransStreamInvokesLow,
               applPastTransStreamInvCumTimes,
               applPastTransStreamInvRspTimes,
               applPastTransStreamPerformsLow,
               applPastTransStreamPrfCumTimes,
               applPastTransStreamPrfRspTimes,
               applPastTransFlowTransLow,
               applPastTransFlowBytesLow,
               applPastTransFlowTime,
               applPastTransKindTransLow,
               applPastTransKindBytesLow,
               applPastTransKindTime }
     STATUS current
     DESCRIPTION
         "This group represents historical data for transaction-
          structured information streams."
     ::= { applicationMibGroups 7 }
 applicationFastTransHistoryGroup OBJECT-GROUP
     OBJECTS { applPastTransFlowTrans,
               applPastTransFlowBytes,
               applPastTransKindTrans,
               applPastTransKindBytes,
               applPastTransStreamPerforms,
               applPastTransStreamInvokes }
     STATUS current
     DESCRIPTION
         "This group contains 64-bit objects required for historical
          records on high-volume transaction-structured streams,
          where 32-bit integers would be insufficient."
     ::= { applicationMibGroups 8 }
 applicationRunGroup OBJECT-GROUP
     OBJECTS { applElmtRunStatusSuspended,
               applElmtRunStatusHeapUsage,
               applElmtRunStatusOpenConnections,
               applElmtRunStatusOpenFiles,
               applElmtRunStatusLastErrorMsg,
               applElmtRunStatusLastErrorTime,

Kalbfleisch, et al. Standards Track [Page 77] RFC 2564 Application Management MIB May 1999

               applElmtRunControlSuspend,
               applElmtRunControlReconfigure,
               applElmtRunControlTerminate }
     STATUS current
     DESCRIPTION
         "This group represents extensions to the system application
          MIB."
     ::= { applicationMibGroups 9 }
 applicationMibCompliance MODULE-COMPLIANCE
     STATUS current
     DESCRIPTION "The compliance statement for the application MIB."
     MODULE
         MANDATORY-GROUPS { applicationMonitorGroup,
                            applicationHistoryGroup,
                            applicationRunGroup }
             OBJECT applPastChannelControlCollect
                 MIN-ACCESS read-only
                 DESCRIPTION
                     "This object should be limited to read-only
                      access in environments with inadequate
                      security."
             OBJECT applPastChannelControlMaxRows
                 MIN-ACCESS read-only
                 DESCRIPTION
                     "This object should be limited to read-only
                      access in environments with inadequate
                      security."
             OBJECT applPastChannelControlTimeLimit
                 MIN-ACCESS read-only
                 DESCRIPTION
                     "This object should be limited to read-only
                      access in environments with inadequate
                      security."
             OBJECT applElmtRunControlSuspend
                 MIN-ACCESS read-only
                 DESCRIPTION
                     "This object should be limited to read-only
                      access in environments with inadequate
                      security."

Kalbfleisch, et al. Standards Track [Page 78] RFC 2564 Application Management MIB May 1999

             OBJECT applElmtRunControlReconfigure
                 MIN-ACCESS read-only
                 DESCRIPTION
                     "This object should be limited to read-only
                      access in environments with inadequate
                      security."
             OBJECT applElmtRunControlTerminate
                 MIN-ACCESS read-only
                 DESCRIPTION
                     "This object should be limited to read-only
                      access in environments with inadequate
                      security."
         GROUP applicationTransactGroup
         DESCRIPTION
             "The applicationTransactGroup is required when the
              information stream processed has a transaction
              structure. "
         GROUP applicationTransHistoryGroup
         DESCRIPTION
             "The applicationTransHistoryGroup must be implemented
              if applicationTransactGroup and applicationHistoryGroup
              are implemented."
         GROUP applicationFastMonitorGroup
         DESCRIPTION
            "The applicationFastMonitorGroup is mandatory when
             the applicationMonitorGroup is implemented and its
             counts group may exceed what can be represented in 32 bits."
         GROUP applicationFastTransactGroup
         DESCRIPTION
            "The applicationFastTransactGroup is mandatory when
             the applicationTransactGroup is implemented and its
             counts may exceed what can be represented in 32 bits."
         GROUP applicationFastHistoryGroup
         DESCRIPTION
            "The applicationFastHistoryGroup is mandatory when
             the applicationHistoryGroup is implemented and its
             counts may exceed what can be represented in 32 bits."

Kalbfleisch, et al. Standards Track [Page 79] RFC 2564 Application Management MIB May 1999

         GROUP applicationFastTransHistoryGroup
         DESCRIPTION
            "The applicationFastTransHistoryGroup is mandatory when
             the applicationTransHistoryGroup is implemented and its
             counts may exceed what can be represented in 32 bits."
     ::= { applicationMibConformance 2 }
 END

6. Implementation Issues

 Unlike the system application MIB [31], in many environments support
 for much of this MIB requires instrumentation built into the managed
 resource.  Some tables may be implemented by a single monitor
 process; for others, the implementation may be distributed within the
 managed system with the resources being managed.
 As a practical matter, this means that the management infrastructure
 of the managed system must support different subagents taking
 responsibility for different rows of a single table.  This can be
 supported by AgentX [25], as well as some other subagent protocols
 such as [8], [9], and [11].
 The sysApplRunElmtIndex is the key connection between this MIB and
 the systems application MIB.  Implementations of these two MIBs
 intended to run concurrently on a given platform must employ a
 consistent policy for assigning this value to running application
 elements.
 Some of the objects defined in this MIB may carry a high run-time
 cost in some environments.  For example, tracking transaction elapsed
 time could be expensive if it required two kernel calls (start and
 finish) per transaction.  Similarly, maintaining tables of per-
 transaction information, rather than aggregating information by
 transaction type or transaction stream, could have significant
 storage and performance impacts.
 Unless a collision-free mechanism for allocating service instance
 indexes is in place, the structure of the service-level tables makes
 an index-reservation mechanism necessary.  AgentX [25] is an example
 of a subagent protocol capable of satisfying this requirement.

7. Intellectual Property

 The IETF takes no position regarding the validity or scope of any
 intellectual property or other rights that might be claimed to
 pertain to the implementation or use of the technology described in

Kalbfleisch, et al. Standards Track [Page 80] RFC 2564 Application Management MIB May 1999

 this document or the extent to which any license under such rights
 might or might not be available; neither does it represent that it
 has made any effort to identify any such rights.  Information on the
 IETF's procedures with respect to rights in standards-track and
 standards-related documentation can be found in BCP-11.  Copies of
 claims of rights made available for publication and any assurances of
 licenses to be made available, or the result of an attempt made to
 obtain a general license or permission for the use of such
 proprietary rights by implementors or users of this specification can
 be obtained from the IETF Secretariat.
 The IETF invites any interested party to bring to its attention any
 copyrights, patents or patent applications, or other proprietary
 rights which may cover technology that may be required to practice
 this standard.  Please address the information to the IETF Executive
 Director.

8. Acknowledgements

 This document was produced by the Application MIB working group.
 The editor gratefully acknowledges the comments and contributions of
 the following individuals:
   Harrie Hazewinkel
   Carl Kalbfleisch
   Cheryl Krupczak
   David Partain
   Jon Saperia
   Juergen Schoenwaelder
   Kenneth White

9. Security Considerations

 By making potentially sensitive information externally accessible,
 the capabilities supported by the MIB have the potential of becoming
 security problems.  How security fits into SNMP frameworks is
 described in [26], and a specific access control model is described
 in [30].
 The tables in this MIB are organized to separate sensitive control
 capabilities from less sensitive usage information.  For example, the
 objects to control application suspend/resume are separated from
 those to handle reconfiguration, which in turn are distinct from
 those for termination.  This recognizes the need to support
 configurations where the level of authorization needed by a manager
 to do a "reconfigure" might be substantially less than the level
 needed to terminate an application element.  By keeping these in

Kalbfleisch, et al. Standards Track [Page 81] RFC 2564 Application Management MIB May 1999

 separate columns, we make it possible to set up access control that
 allows, for example, "reconfigure" but not "kill".
 The MIB is structured to be useful for managers with read-only access
 rights.  In some environments, it may be approprate to restrict even
 read-only access to these MIBs.
 The capabilities supported by this MIB include several that may be of
 value to a security administrator.  These include the ability to
 monitor the level of usage of a given application, and to check the
 integrity of application components.

10. References

 [1]  ARM Working Group, "Application Response Measurement (ARM) API
      Guide, Version 2", September, 1997.
 [2]  IEEE P1387.2, POSIX System Administration - Part 2: Software
      Administration.  (Draft)
 [3]  ITU-T Recommendation X.744 | ISO/IEC IS 10164-18:1996,
      Information Technology - Open Systems Interconnection - Systems
      Management: Software Management Function, 1996.
 [4]  Rose, M. and K. McCloghrie, "Structure and Identification of
      Management Information for TCP/IP-based Internets", STD 16, RFC
      1155, May 1990.
 [5]  Case, J., Fedor, M., Schoffstall, M. and J. Davin, "Simple
      Network Management Protocol", STD 15, RFC 1157, May 1990.
 [6]  Rose, M. and K. McCloghrie, "Concise MIB Definitions", STD 16,
      RFC 1212, March 1991.
 [7]  Rose, M., "A Convention for Defining Traps for use with the
      SNMP", RFC 1215, March 1991.
 [8]  Rose, M., "SNMP MUX Protocol and MIB", RFC 1227, May 1991.
 [9]  Carpenter, G. and B. Wijnen, "SNMP-DPI Simple Network Management
      Protocol Distributed Program Interface", RFC 1228, May 1991.
 [10] Grillo, P. and S. Waldbusser, "Host Resources MIB", RFC 1514,
      September 1993.
 [11] Carpenter, G., Curran, K., Sehgal, A., Waters, G. and B.
      Wijnen, "Simple Network Management Protocol Distributed Protocol
      Interface Version 2.0", RFC 1592, March 1994.

Kalbfleisch, et al. Standards Track [Page 82] RFC 2564 Application Management MIB May 1999

 [12] Brower, D., Purvy, R., Daniel, A., Sinykin, M. and J. Smith,
      "Relational Database Management System (RDBMS) Management
      Information Base (MIB) using SMIv2", RFC 1697, August 1994.
 [13] Reynolds, J. and J. Postel, "Assigned Numbers", STD 2, RFC 1700,
      October 1994.
 [14] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser,
      "Introduction to Community-based SNMPv2", RFC 1901, January
      1996.
 [15] McCloghrie, K., Perkins, D. and J. Schoenwaelder, "Structure of
      Management Information Version 2 (SMIv2)", STD 58, RFC 2578,
      April 1999.
 [16] McCloghrie, K., Perkins, D. and J. Schoenwaelder, "Textual
      Conventions for SMIv2", STD 58, RFC 2579, April 1999.
 [17] McCloghrie, K., Perkins, D. and J. Schoenwaelder, "Conformance
      Statements for SMIv2", STD 58, RFC 2580, April 1999.
 [18] 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.
 [19] Case, J., McCloghrie, K., Rose, M. and S. Waldbusser, "Transport
      Mappings for Version 2 of the Simple Network Management Protocol
      (SNMPv2)", RFC 1906, January 1996.
 [20] McCloghrie, K. and A. Bierman, "Entity MIB using SMIv2", RFC
      2037, October 1996.
 [21] Kalbfleisch, C., "Applicability of Standards Track MIBs to
      Management of World Wide Web Servers", RFC 2039, November 1996.
 [22] Bradner, S., "Key words for use in RFCs to Indicate Requirement
      Levels", BCP 14, RFC 2119, March 1997.
 [23] Freed, N. and S. Kille, "Network Services Monitoring MIB", RFC
      2248, January 1998.
 [24] Freed, N. and S. Kille, "Mail Monitoring MIB", RFC 2249, January
      1998.
 [25] Daniele, M., Francisco, D. and B. Wijnen, "Agent Extensibility
      (AgentX) Protocol", RFC 2257, January, 1998.
 [26] Harrington, D., Presuhn, R. and B. Wijnen, "An Architecture for

Kalbfleisch, et al. Standards Track [Page 83] RFC 2564 Application Management MIB May 1999

      describing SNMP Management Frameworks", RFC 2571, May 1999.
 [27] Case, J., Harrington D., Presuhn R. and B. Wijnen, "Message
      Processing and Dispatching for the Simple Network Management
      Protocol (SNMP)", RFC 2572, May 1999.
 [28] Levi, D., Meyer, P. and B. Stewart, "SNMPv3 Applications", RFC
      2573, May 1999.
 [29] Blumenthal, U. and B. Wijnen, "User-based Security Model (USM)
      for version 3 of the Simple Network Management Protocol
      (SNMPv3)", RFC 2574, May 1999.
 [30] Wijnen, B., Presuhn, R. and K. McCloghrie, "View-based Access
      Control Model for the Simple Network Management Protocol
      (SNMP)", RFC 2575, May 1999.
 [31] Krupczak, C. and J. Saperia, "Definitions of System-Level
      Managed Objects for Applications", RFC 2287, February 1998.

11. Authors' Addresses

 Carl Kalbfleisch
 Verio, Inc.
 1950 Stemmons Freeway
 2004 INFOMART
 Dallas, TX 75207
 USA
 Phone: +1 972-238-8303
 Fax:   +1 972-238-0268
 EMail: cwk@verio.net
 Cheryl Krupczak
 Empire Technologies, Inc.
 541 Tenth Street, NW Suite 169
 Atlanta, GA 30318
 USA
 Phone: +1 770-384-0184
 EMail: cheryl@empiretech.com

Kalbfleisch, et al. Standards Track [Page 84] RFC 2564 Application Management MIB May 1999

 Randy Presuhn (Editor)
 BMC Software, Inc.
 965 Stewart Drive
 Sunnyvale, CA 94086
 USA
 Phone: +1 408-616-3100
 Fax:   +1 408-616-3101
 EMail: randy_presuhn@bmc.com
 Jon Saperia
 IronBridge Networks
 55 Hayden Avenue
 Lexington, MA 02173
 USA
 Phone: +1 781-402-8029
 Fax:   +1 781-402-8090
 EMail: saperia@mediaone.net

Kalbfleisch, et al. Standards Track [Page 85] RFC 2564 Application Management MIB May 1999

12. Full Copyright Statement

 Copyright (C) The Internet Society (1999).  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.

Acknowledgement

 Funding for the RFC Editor function is currently provided by the
 Internet Society.

Kalbfleisch, et al. Standards Track [Page 86]

/data/webs/external/dokuwiki/data/pages/rfc/rfc2564.txt · Last modified: 1999/05/12 21:23 (external edit)