RBSLA: Rule-based Service Level Agreements

Rule-based Contract Representation and Management for electronic Contracts, Policies and Service Level Agreements

Contact: Adrian Paschke
Internet-based Information Systems, Technische Universität München

Keywords

IT Service Management (ITSM), Service Level Management (SLM), Service Level Agreements (SLA) and Policies, SLA metrics, Service-oriented Architectures (SOA), Event-driven Architectures (EDA), Contract Representation, Contract Management, SLA Monitoring, Business Rules, Knowledge Representation, Rule Engines, Artificial Intelligence, Logic, Utility Computing, On-Demand Computing, Grid Computing, Web Services, Defeasible Deontic Logic with Norm Violations and Exceptions, Logic of Norms, Conditional Obligations, Contrary-To-Duty Obligations and Defeasible Prima Facie Obligations, Event Calculus, Complex Event Processing, Interval-based Event Algebra, Defeasible Logic with Integrity Constraints and Rule Prioirties, Typed Logic with Polymorphic Order-Sorted Typed Unification, Hybrid Description Logic Programs (Heterogeneous DLP approach with Jena and Pellet) for Semantic Web Typing, Constraint LPs, Active ECA Rules and Transaction Logic, Event Condtion Action (ECA), Temporal Logic, RuleML, RBSLA, Test-driven Validation, Test Cases, Test Coverage, Integrity Constraints, Ordered Logic Programs (OLPs).

Summary

The domain of electronic contracts such Service Level Agreements or high-level policies typically faces rapidly changing business and system environments, huge amounts of scattered contracts and data managed in possibly distributed heterogeneous external data sources and a great variety of more or less cooperative roles (human or automated agents) which are  involved during the contract life cycle. Moreover, it has high requirements regarding correctness, reliability and traceability of drawn conclusions and triggered reactions in order to establish trust and fulfil legal compliance rules.

Rule based systems and in particular declarative logic programming (LP) qualifies to be the right representation and execution environment for representing, monitoring and enforcing electronic contracts such as SLAs. However, adequate rule-based representation, monitoring and enforcement of SLAs or policies needs more expressiveness than provided by standard rule engines such as Prolog interpreters, e.g. in order to actively react to occurred events, compute complex events or actions, reason over their temporal effects on the SLA state, automatically resolve arising conflicts due to knowledge updates and dynamic changes or enforce agreed rights or obligations.

The ContractLog KR and the superimposed RBSLA mark up language provide selected logical formalisms and inference services to adequately represent, manage, interchange and execute formalized rule-based SLAs or policy contracts. The ContractLog approach exploits common logic programming techniques and combines them with Semantic Web technologies (RDFS / OWL ontologies) and procedural object-oriented Java and database functionalities in order to enable a tight integration of declarative rule specifications with existing external programs, systems, vocabularies and data bases which are typically used in the system, web and network management domain. Remarkably, the RBSLA approach in contrast to existing languages in the SLA domain such as WSLA, WSOL, WS-Agreement, is not just a pure syntactical specification language with predefined language constructs, but is a declarative rule-based programming language with an operational and a declarative logic- based semantics for formalizing and implementing arbitrary contract-related functionalities and specifications. This declarative implementation-oriented design provides maximum flexibility and extensibility for SLA representation including the use of different contract vocabularies written as Semantic Web ontologies such as WSMO, WS-Policy OWL ontology or KAoS and other ontologies such as OWL time, which can be integrated as external webized type systems into the logical SLA rules, giving them a domain-specific meaning.

Compared to traditional contract management tools, the rule-based approach has the following major advantages:

• contract rules are externalized and easily shared among multiple applications and domains (avoiding vendor lock-in) ;
• encourages reuse and shortens development time;
• changes can be made faster and with less risk;
• lowers cost incurred in the modification of contractual business and reaction logic;

Overview

The emergence of service-oriented architectures (SOA) and event-driven architectures (EDA) together with technology standards like Web Services and Grid Computing and upcoming On-Demand or Utility Computing models leverage an environment based upon loosely coupled and distributed services and dynamic service provider and service consumer relationships. Accordingly, the need for automated management and monitoring of service contracts like Service Level Agreements (SLAs) increases. The prevailing system management tools and natural language defined contracts are not suitable to solve this task. In a global computing economy, service providers will have to monitor and execute thousands of contracts, potentially across different service customers, with complex contract rules on an individual or a group level. Contract management tools need to be able to automatically detect contract and norm violations, to check rule sets for consistency, and to perform automated rule chaining for representing sophisticated distributed business policies (e.g. differentiated pay-per-use pricing rules or complex quality of service (QoS) rules on a business level). This requires new ways of knowledge representation for contractual agreements and new technical solutions for contract monitoring and contract enforcement.

The Rule Based Service Level Agreements (RBSLA) project focuses on sophisticated knowledge representation concepts for service level management (SLM) of IT services. At the core of our contract and service level management tool are rule-based languages to describe contracts such as service level agreements or policies in a generic way. The research draws on basic knowledge representation concepts from the area of artificial intelligence (AI) and knowledge representation (KR) and as well as on new standards in the area of web services computing and the semantic web. A particular interest is the investigation of expressive logic programming techniques and logical formalisms such as defeasible logic, deontic logic, temporal event/action logics, transaction and update logics, description logics as a means of deriving formal declarative contract specifications with which to reason about ideal and actual behaviours relating to agreed contract norms (permissions, obligations and prohibitions and their violations (contrary-to-duty obligations) or exceptions (defeasible prima facie obligations)). The developed novel and unique KR (ContractLog KR) and the rule-based mark-up language for SLA representation (RBSLA mark up language) combine selected adequate logical concepts to describe complex contract rules. An implementation of a rule-based service level management tool (RBSLM) is being built with a computational model based on the ContractLog KR and the open source rule engine Prova.

The important advantages of our approach are the automated verification, validation and consistency checks of large possibly distributed and interchanged rule sets, the automated chaining, (scoped) reasoning and execution of rules and distributed contract modules as well as the flexibility in the dynamic extension with new contract rules (dynamic transactional updates). This facilitates contracts which are flexible and thus able to adapt in order to meet changes to service requirements dynamically with the indispensable minimum of service execution disruption at runtime, possibly permitting coexistence of differentiated contract variants and simplifying contract management and contract execution.

More Information

• Paschke, A., Dietrich, J., Giurca, A., Wagner, G., Lukichev, S.: On Self-Validating Rule Bases, Int. Semantic Web Enabled Software Engineering Workshop (SWESE'06 at ISWC'06), Athens, Georgia, USA. (pdf)
• Pasche, A. and Bichler, M.: Knowledge Representation Concepts for Automated SLA Management, Int. J. of Decision Support Systems (DSS), under review, 2006.
• Paschke, A.: A Typed Hybrid Description Logic Programming Language with Polymorphic Order-Sorted DL-Typed Unification for Semantic Web Type Systems, OWL-2006 (OWLED'06), Athens, Georgia, USA, 2006. (pdf)
• Paschke, A.: Verification, Validation and Integrity of Distributed and Interchanged Rule Based Policies and Contracts in the Semantic Web, Int. Semantic Web and Policy Workshop (SWPW at ISWC 06), Athens, Georgia, USA, 2006. (pdf)
• Paschke, A.: ECA-RuleML/ECA-LP: A Homogeneous Event-Condition-Action Logic Programming Language, Int. Conf. of Rule Markup Languages (RuleML'06), Athens, Georgia, USA, 2006. (pdf)
• Paschke, A.: ECA-RuleML 0.2: A Homogeneous Event-Condition-Action Logic Programming Language for RuleML , Reaction RuleML TG, Technical Telephone Conference, 2006-09-21 (slides)
• Paschke, A.: Rule-based Knowledge Representation for Service Level Agreements , Doctoral Symposium of MATES'06 (MATES'06), Germany, 2006.( pdf)
• Paschke, A.: The Mandarax RDF / RDFS/ OWL / DLP Module - Integration of Semantic Web Data into the Rule Engine Manadarax. International Workshop on Rule-Based Modeling and Simulation of Interacting Systems and Agents (AORML), Cottbus, Germany, Feb. 2006. (pdf)
• Paschke, A.: The Rule Based Service Level Agreement Project (RBSLA). International Workshop on Rule-Based Modeling and Simulation of Interacting Systems and Agents (AORML), Cottbus, Germany, Feb. 2006. (pdf)
• Paschke, A.: Typed Hybrid Description Logic Programs with Order-Sorted Semantic Web Type Systems based on OWL and RDFS, Internet Based Information Systems, Technical University Munich, Technical Report 12/05, 2005. (pdf)
• Paschke, A.: RBSLA - A declarative Rule-based Service Level Agreement Language based on RuleML, International Conference on Intelligent Agents, Web Technology and Internet Commerce (IAWTIC 2005), Vienna, Austria, 2005. (pdf) (pres.)
• Paschke, A. and Kozlenkov, A.: ECA-RuleML: An Approach combining ECA Rules with temporal interval-based KR Event/Action Logics and Transactional Update Logics , IBIS, Technische Universität München, Technical Report 11 / 2005. (pdf)
• Paschke, A. : ECA-LP: A Homogeneous Event-Condition-Action Logic Programming Language, IBIS, Technische Universität München, Technical Report 11 / 2005. (pdf)
• Paschke, A., Bichler, M., Dietrich, J.: ContractLog: An Approach to Rule Based Monitoring and Execution of Service Level Agreements, International Conference on Rules and Rule Markup Languages for the Semantic Web (RuleML 2005), Galway, Ireland, 2005. (pdf) (pres.)
• Paschke, A., Dietrich, J., Kuhla, K.: A Logic Based SLA Management Framework, Semantic Web and Policy Workshop (SWPW), 4th Semantic Web Conference (ISWC 2005), Galway, Ireland, 2005. (pdf)
• Paschke, A.: The ContractLog Approach Towards Test-driven Verification, Validation and Integrity of Distributed Scoped Rule Bases - A Homogeneous Integration of Test Cases and Integrity Constraints into Dynamic Labelled Scoped Update Logic Programs and Rule Markup Languages (RuleML), IBIS, TUM, Technical Report 10/05. (pdf)
• Paschke, A., Schnappinger-Gerull, E.: A Categorization Scheme for SLA Metrics. IBIS, TUM, Technical Report 09/05.
• Jens Dietrich and Adrian Paschke, On the Test-Driven Development and Validation of Business Rules, 4th International Conference on Information Systems Technology and its Applications (ISTA 2005), New Zealand, May 2005. (pdf)(pres.)
• Paschke, A., Bichler, M.: SLA Representation, Management and Enforcement - Combining Event Calculus, Deontic Logic, Horn Logic and Event Condition Action Rules, E-Technology, E-Commerce, E-Service Conference (EEE05), Hong Kong, 2005. (pdf)
• Paschke, A., Kiss, C., Al-Hunaty, S.: A Pattern Language for Decentralized Coordination and Negotiation Protocols, E-Technology, E-Commerce, E-Service Conference (EEE05), Hong Kong, March 2005. (pdf)
• Paschke, A.: Contract Management for IT-Services, Poster at CEC05 / Open House Day TUM, 2005, (engl.)
• Paschke,A., Bichler, M.: Repräsentation und automatisiertes Management von IT-Service-Verträgen - Ein Ansatz zum Einsatz wissensbasierter Systeme für die Repräsentation, Automatisierung und das Management elektronischer Dienstleistungsverträge, IBIS, TUM, Technical Report, 10/2004. (abstract)
• Bichler, M., Diernhofer, N., Fay, F., König, C., MacWilliams, A., Paschke, A., Setzer, T., Völk, G.: "Dynamic Value Webs for IT-Services - IT-Service Technologies and Management, Siemens SBS / TUM research study, 10/2004
• Paschke, A., RBSLA: A Rule Based Service Level Agreements Language based on RuleML. IBIS, TUM, Technical Report 8/2005.
• Paschke, A.: ContractLog - A Logic Framework for SLA Representation, Management and Enforcement. IBIS, TUM, Technical Report, 07/2004.
• Paschke, A..: Regelbasiertes SLA-Management - Ein regelbasierter Ansatz zum automatisierten IT-Dienstleistungsmanagement, IBIS, TUM, Technical Report, 6/2004.
• Paschke, A.: Contract Management for IT-Services, Poster at Open House Day TUM 2004, (engl.) (ger.)
• Paschke, A.: Rule-based Service Level Agreements, Presentation at the IBIS strategic seminar, 2004 (pdf)
• Paschke, A., Bichler, M.: Regelsprachen zur Beschreibung elektronischer Verträge - Ein Konzept zum Einsatz wissensbasierter Systeme für die Entwicklung flexibler internetbasierter Geschäftssysteme. Technical Report, IBIS, 04/2003.
• Paschke, A.: eContracting - an overview of relevant language standards, Talk at IBIS, 2003 (pdf)

Implementations

Our implementation is structured into four layers: The Prova rule engine, the ContractLog KR, the declarative Rule Based Service Level Agreement Markup Language (RBSLA) and the Rule Based Service Level Management (RBSLM) tool.

Layered Architecture of the Rule Based SLA Approach

		The Prova Rule Engine
		http://www.prova.ws/
		Prova positions itself as a rule-based scripting (RBS) system for middleware. The language breaks new ground in combining imperative and declarative programming. Prova is derived from Mandarax Java-based inference system developed by Jens Dietrich. Prova extends Mandarax by providing a proper language syntax, native syntax integration with Java, and agent messaging and reaction rules. The design goals of Prova Marry the benefits of declarative and object-oriented programming; Combine the syntaxes of Prolog and Java—ultimate logic and object-oriented languages; Expose logic and agent behaviour as rules; Access data sources via wrappers written in Java or command-line shells like Perl; Make all Java API from available packages directly accessible from rules; Run within the Java runtime; Enable rapid prototyping of applications; Offer a rule-based platform for distributed agent programming and reactive Event-driven Architectures (EDA)

		The ContractLog KR
		More Info
		The ContractLog KR is the formal logical core of the RBSLA approach. It combines several adequate logical formalisms needed for the representation and automated execution of SLAs such as temporal event/action logics, reactive rules logic (ECA), deontic logics,  typed/labelled logic as well as concepts from the Semantic Web description logics and defeasible reasoning to describe active SLA rules, rights and obligations with norm violations (e.g. conditional contrary-to-duty obligations) and exceptions (defeasible obligations), domain specific contract vocabularies/ontolgies, contract modules with rule precedences and default (exception) rules etc. ContractLog is implemented on top of the backward-reasoning rule engine Prova which is an open source java-based rule engine for backward reasoning derivation rules. It uses the Prova scripting lanugage (related to ISO Prolog syntax) to implement sophisticated (non-monotonic) logical formalisms (Event Calculus, Defeasible Ordered Logic, Defeasible Deontic Logic with Norm Violations and Exceptions etc.) using declarative logic programming techniques. It provides a library of Prova script files which contain the different logic and metaprogramming implementations together with several Java based extensions to Mandarax and Prova for example to execute active, multi-threaded Event Condition Action (ECA) rules (info) which are often used in SLAs. The ContractLog library can be directly used to write formal rule based SLAs which can be loaded and executed in Prova.

		The Rule Based Service Level Agreement Language (RBSLA)
		More Info
		The Rule Based Service Level Agreement Markup Language (RBSLA) is a general, practical, compact and user-friendly XML-serialized language for the serialization, distributed management and interchange of electronic contracts such as SLAs or higher-level policies. Our goal is to stay close to the emerging XML-based Rule Markup language (RuleML and ReactionRuleML) in order to address interoperability with other rule languages and tool support. We extend RuleML with SLA specific concepts and logical constructs abstracted from the ContractLog KR. The language fulfils typical criteria for good language design such as minimality, symmetry and orthogonality. With minimality we mean that RBSLA provides only a small set of needed language constructs in addition to the existing constructs in RuleML, i.e., the same meaning cannot be expressed by different language constructs. Symmetry is fulfilled in so far as the same language constructs always expresses the same semantics regardless of the context they are used in. Orthogonality permits every meaningful combination of a language constructs to be applicable. Moreover, RBSLA satisfies typical knowledge representation adequacy criteria such as epistemological adequacy w.r.t. the various application domains of reaction/action/production rules and KR event / action logics: "A representation is called epistemologically adequate for a person or a machine if it can be used practically to express the facts that one actually has about the aspects of the world.„ McCarthy/Hayes 1969 The RBSLA language simplyfies writing SLAs and policies by means of abstracted language constructs to define SLA/policy rules and facilitates the use of existing XML tools. Additionally it provides means for optimizing/refactoring and validation of rule sets during the transformation into the executable ContractLog KR via a transformation process.

		The Rule Based Service Level Management Tool (RBSLM)
		More Info
		The RBSLM tool divides into two partitions: the Contract Manager (CM) and the Service Dashboard (SD). The CM is used to manage, write, maintain and update SLA rules. The SD visualizes the monitoring and enforcement process during the contract life cycle and supports further SLM processes. Exemplary Service Dashboard Views

Downloads

Sourceforge RBSLA / ContractLog Distribution v. 0.2

Sourceforge Prova 2.0 - The Prova Rule Engine and Scripting Syntax with ContractLog and RBSLA extension
Mandarax RDF/OWL API 1.1 - Integration Framework for Semantic Web RDF, RDFS and OWL into Mandarax
Mandarax Event Calculus EC 1.0 - Event Calculus Extension for Mandarax
Sourceforge Mandarax 3.4 - The Mandarax Core Java Rule Engine

RBSLA v. 0.3 - The Rule Based Service Level Agreement Markup Language
Reaction RuleML v. 0.1 - The Reaction Rules Markup Language
RuleML - The Rule Markup Language Initiative

Associated projects

Mandarax
Prova
Jena
Pellet
RuleML
Reaction RuleML
IT Service Operations Management