Internet Core Protocols/Oreilly-InternetCoreProtocols.iso/RFCs/rfc2564.txt

Text File | 1999-10-14 | 183.7 KB | 4,820 lines

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


     -      Support for generic application throughput measurements;

     -      Providing MIB definitions that allow managed entities to
            report what they considered to be units of work;

     -      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].)

     -      Provide explicit support for the management of applications
            distributed within a single managed system ("local"
            distribution);

     -      Address generic resource management issues, including:

            -      files in use;

            -      I/O statistics (from the application's perspective,
                   not at the operating system or device driver level);

            -      application-layer networking resource usage

     -      Facilities for the control of applications, including:

            -      Stopping application elements

            -      Suspending and resuming application elements;

            -      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:

     -      the systems applications MIB [31]

     -      the host resources MIB [10]

     -      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:

     -      the service-level view of applications

     -      information on open channels (files, connections,
            transaction streams) in use by applications

     -      historical information on former channels

     -      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:

     -      the tables providing a service-level view, including:

            -      the service name to service instance table

            -      the service instance to service name table

            -      the service instance to running application element
                   table

            -      the running application element to service instance
                   table

     -      the tables providing information on I/O channels, including:

            -      the table of open channels

            -      the table of open files

            -      the open connections table

            -      the transaction statistics tables

     -      historical information on I/O channels

     -      the running application element status and control group

            -      the running application element status table

            -      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:

     -      is there an identifiable set of resources associated with
            providing this service?

     -      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:

     -      time at which the channel was opened

     -      number of read requests

     -      number of bytes read

     -      time at which most recent read operation was initiated

     -      number of write requests

     -      number of bytes written

     -      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:

     -      file name

     -      file size

     -      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:

     -      identification of the transport protocol in use

     -      near-end address and port

     -      far-end address and port

     -      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:

     -      identification of the underlying connection or file used for
            this transaction stream

     -      a human-readable description of this stream

     -      a human-readable description of this stream's notion of what
            a unit of work is

     -      the cumulative amount of time spent (as an operation
            invoker) waiting for responses (from queueing of request to
            arrival of first response)

     -      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)

     -      the cumulative amount of time spent (as an operation
            performer) handling requests (time from receipt of request
            to queueing of first outgoing response)

     -      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



     -      the cumulative number of transactions initiated (as an
            invoker)

     -      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:

     -      the number of transactions processed

     -      the number of bytes processed

     -      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.

     -      number of transactions processed

     -      number of bytes processed

     -      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:

     -      current heap usage for this running application element

     -      current number of open network connections for this running
            application element

     -      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:

     -      a suspend/resume control

     -      a reconfiguration request control

     -      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: [phone]
           Facsimile: [phone]
           EMail: [e-mail]
          "
       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 }


   --
   --      Registration hierarchy for this MIB
   --
   applicationMibObjects OBJECT IDENTIFIER ::=
                            { applicationMib 1 }



Kalbfleisch, et al.         Standards Track                    [Page 16]

RFC 2564               Application Management MIB               May 1999


   applicationMibConformance OBJECT IDENTIFIER ::=
                            { applicationMib 2 }


   --
   --      Groups defined in this MIB
   --
   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


   -- ****************************************************************
   --
   --      applServiceGroup -
   --
   --      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 services.
   --
   -- ****************************************************************


   -- ****************************************************************
   --
   --      The service name to service instance table
   --
   -- ****************************************************************

   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 }


   -- ****************************************************************
   --
   --      Service instance to Service Name table
   --
   -- ****************************************************************

   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 }

   -- ****************************************************************
   --
   --      The service instance to running application element table
   --
   -- ****************************************************************

   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


   -- ****************************************************************
   --
   --      The running application element to service instance table
   --
   -- ****************************************************************

   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 }


   -- ****************************************************************
   --
   --      applChannelGroup - group with tables for I/O
   --
   --      In this group, the common abstraction is the Channel.
   --      Channels are realized as files or connections.
   --      The information flowing on a channel can always be
   --      measured in terms of a byte stream.  Furthermore, for many
   --      channels, this information may also be measured in terms
   --      of transactions.
   --
   --      For all of these tables, the first two indexes determines
   --      whether what is being measured is for a single running
   --      application element or for an instance of a service.
   --
   --      The second index identifies the running application element
   --      or service instance.
   --
   --      The third index is the channel id, which uniquely identifies
   --      a channel within the context of a running application element
   --      or service instance.
   --
   --      Any remaining indexes are table-specific.
   --
   -- ****************************************************************


   -- ****************************************************************
   --
   --      applOpenChannelTable - Table of Open Channels
   --
   -- ****************************************************************

   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 }

   -- ****************************************************************
   --
   --      applOpenFileTable - Table of Open Files
   --
   -- ****************************************************************

   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 }


   -- ****************************************************************
   --
   --      applOpenConnectionTable - Open Connection Table
   --
   -- ****************************************************************

   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


   -- ****************************************************************
   --
   --      applTransactionStreamTable - common
   --      information for transaction stream monitoring
   --
   -- ****************************************************************

   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


   -- ****************************************************************
   --
   --      applTransactFlowTable
   --
   -- ****************************************************************

   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 }

   -- ****************************************************************
   --
   --      applTransactKindTable - transaction statistics broken down
   --      according to the kinds of transactions in each direction
   --      for a transaction stream.
   --
   -- ****************************************************************

   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


   -- ****************************************************************
   --
   --      applPastChannelGroup - logged information on former channels.
   --      These tables control the collection of channel history
   --      information and represent the accumulated historical data.
   --
   -- ****************************************************************

   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'

                   - the entry has been in the table longer that the
                     time limit indicated by the corresponding
                     applPastChannelControlTimeLimit.
             "
           ::= { applPastChannelControlEntry 4 }


   -- ****************************************************************
   --
   --      applPastChannelTable - Table of former channels
   --
   -- ****************************************************************

   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:

                   - the running application element or service
                     instance no longer exists

                   - the corresponding applPastChannelControlCollect
                     attribute has been set to 'disabled'

                   - 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'

                   - 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.

                   - 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 }

   -- ****************************************************************
   --
   --      applPastFileTable - information specific to former files
   --
   -- ****************************************************************







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 }

   -- ****************************************************************
   --
   --      applPastConTable - information specific to former connections
   --
   -- ****************************************************************





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 }


   -- ****************************************************************
   --
   --      applPastTransStreamTable - historical
   --      information for transaction stream monitoring
   --
   -- ****************************************************************



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 }


   -- ****************************************************************
   --
   --      applPastTransFlowTable
   --
   -- ****************************************************************

   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 }

   -- ****************************************************************
   --
   --      applPastTransKindTable - transaction statistics broken down
   --      according to the kinds of transactions in each direction
   --      for a transaction stream.
   --
   -- ****************************************************************

   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 }


   -- ****************************************************************
   --
   --      applElmtRunControlGroup - monitor and control running
   --      application elements
   --
   -- ****************************************************************

   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 }


   -- ****************************************************************
   --
   --      applElmtRunControlTable - control running application
   --      elements
   --
   -- ****************************************************************

   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 }


   -- ****************************************************************
   --
   --      Conformance requirements
   --
   -- ****************************************************************

   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: [phone]
   Fax:   [phone]
   EMail: [e-mail]


   Cheryl Krupczak
   Empire Technologies, Inc.
   541 Tenth Street, NW Suite 169
   Atlanta, GA 30318
   USA

   Phone: [phone]
   EMail: [e-mail]









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: [phone]
   Fax:   [phone]
   EMail: [e-mail]


   Jon Saperia
   IronBridge Networks
   55 Hayden Avenue
   Lexington, MA 02173
   USA

   Phone: [phone]
   Fax:   [phone]
   EMail: [e-mail]































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]