Wednesday Dec 04, 2013

Click History Part 2 - Access from Java

In the previous article on Click History I discussed how you can use WLST to dump or export the Click History. In this follow up I wanted to share the code you can use to actually do the same thing from Java.  This is something that you might want to do from within your applications for example to provide in-app diagnostics or from a harvesting process that goes on to archive the records 

Getting the Log Records

The fundamental task here is to dump the circular memory buffer that contains the Click History.

Setup

FIrst of all, to make the correct classes available you will need to add the "JRF Client" library into the project library list  

Code

The key imports you'll need:

import oracle.core.ojdl.reader.LogRecord;
import oracle.core.ojdl.reader.ODLTextLogReader;
import oracle.dfw.dump.DumpContext;
import oracle.dfw.dump.DumpExecutionException;
import oracle.dfw.dump.DumpManager;
import oracle.dfw.dump.DumpResult;
import oracle.dfw.dump.InvalidDumpContextException;
import oracle.dfw.framework.DiagnosticsFramework;

Here's the basic code to dump the buffer:

  DumpManager dumpMgr;
  DiagnosticsFramework df;
  try {
    df = new DiagnosticsFramework();
    dumpMgr = df.getDumpManager();
    DumpContext ctx = DumpContext.createDumpContext("odl.quicktrace");
    ctx.addArgument("handlerName", "apps-clickhistory-handler");
            //now obtain a dump
    DumpResult result;
    try {
      result = dumpMgr.executeDump(ctx);
      if (result != null) {      
        String dumpFile = result.getDumpContext().getDumpPath() +  
                          File.separator + result.getDumpFiles().get(0);
        List<ClickHistoryEntryWrapper> clicks = parseClickHistory(dumpFile);
        //Now do something with clicks....
      }
      else {
        _logger.warning("Warning: excute dump did not return a result");
      }
    } catch (InvalidDumpContextException eidc) {
      _logger.severe("Error invalid Dump Context " + eidc.getMessage());
    } catch (DumpExecutionException edee) {
      _logger.severe("Dump Execution Error " + edee.getMessage());
    }       
  } catch (Exception e) {
            _logger.severe("Error getting diagnostic framework " + e.getMessage());
  } 

The parsing function which reads the dumped file:

  private List<ClickHistoryEntryWrapper> parseClickHistory(String dumpfilename){
    ODLTextLogReader log = ODLTextLogReader.create(dumpfilename, null);    
    List<ClickHistoryEntryWrapper> clicks = new ArrayList<ClickHistoryEntryWrapper>();    
    while (true){
      LogRecord entry = log.read();
      if (entry == null){
        break;
      }
      clicks.add(new ClickHistoryEntryWrapper(entry));            
    }
        
    return clicks;
  } 

And the ClickHistoryEntryWrapper class that "decodes" the LogRecord into a format that is directly usable: 

import java.util.Date;
import java.util.Map;
import oracle.core.ojdl.reader.LogRecord;
public class ClickHistoryEntryWrapper {
  private LogRecord _entry;

  public ClickHistoryEntryWrapper(LogRecord entry) {
    _entry = entry;
  }

  public String getECID() {
    return (String)_entry.getField("EXEC_CONTEXT_UNIQUE_ID");
  }
    
  public int getECIDSeq() {
    return (Integer)_entry.getField("EXEC_CONTEXT_SEQ");
  }
    
  public String getServer() {
    return (String)_entry.getField("COMPONENT_ID");
  }

  public String getDSID() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("DSID");
  }

  public String getUserId() {
    return (String)_entry.getField("USER_ID");
  }
    
  public int getThreadId() {
    return (Integer)_entry.getField("THREAD_ID");
  }

  public String getApplication() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("APP");
  }

  public String getClickComponentType() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_COMPTYPE");
  }

  public String getClickComponentId() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_COMPCLIENTID");
  }

  public String getClickViewId() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_VIEWID");
  }

  public String getClickRegionViewId() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_REGIONVIEWID");
  }

  public Date getClickTime() {
    return new Date(Long.parseLong((String)
              ((Map)_entry.getField("SUPPL_ATTRS")).get("CLICK_STARTTIME")));
  }

  public String getClickType() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_TYPE");
  }

  public String getClickDescription() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_COMPDISPLAYNAME");
  }

  public String getClickRegionViewName() {
    return (String) ((Map) _entry.getField("SUPPL_ATTRS")).get("CLICK_REGIONVIEWNAME");
  }
}

Tuesday Dec 03, 2013

Click History in ADF 12c

In previous posts (see here) I've covered various aspects of logging in ADF and in conjunction with a presentation delivered at the UK Oracle Users Group, I'm continuing the trend with an article on the new Click History functionality within 12c. 

So What is Click History? 

Basically the feature relates to instrumentation that is built into the ADF framework which, when switched on, continuously reports the actions that users have taken within the UI.  This mostly relates to physical clicks on UI elements such as buttons and tabs, but it also reports scrolling events, graph draws and more.  Why is it useful?  Well the point is that it can help answer that particular question - "What did you do before you got the error?" You can see how you could leverage this in a feedback or error reporting function in a UI where the information is extracted and automatically bundled with other useful information for the Support staff to have a look at. 

Each Click History record provides information about the  component, region and view that reported the event, along with key information about the application,  the user and the DSID (Diagnostic Session ID).

Here's a screen shot from some in-application diagnostics that I've developed as an small example.  In this case the history is being dumped and read into the actual application UI.  This is something I'll cover doing in a follow up article. 

Click History Data

Enabling Click History 

As I mentioned Click History is part of the framework in 12c, however, it's not switched on for every application by default.  There will be a performance overhead for any kind of tracing like this so we want to be explicit about choosing to use it. 

In your application itself you need to make 2 small changes:

  1. Create a new web.xml context parameter with the name oracle.adf.view.faces.context.ENABLE_ADF_EXECUTION_CONTEXT_PROVIDER and set the value to true.
  2. Add an extra library reference to your /WEB-INF/ weblogic.xml file (create this if you don't have one already).  Here's the reference you need:

     <library-ref>
       <library-name>odl.clickhistory.webapp</library-name>
     </library-ref> 

Assuming that you have a correctly configured Weblogic domain that has been extended with JRF this library will already be defined for you.  

So in your application, that's basically it. However, we then need to do a little work on the server to configure the server side parameters for this, specifically how much space should be devoted to the Click History buffer.  To explain, Click History has a logical circular buffer of a specified size. As the buffer fills up then new records will be written from the start again and the older records discarded. When you want to look at the history, then you have to dump this buffer, but we'll come to that later. 

Server Side Configuration of Click History 

Switching Click History On or Off

 Although individual applications enable Click History, the server also has to be told to pay attention.  This is very simple to do as it is controlled by switching a particular logger (oracle.clickhistory.EUM) to the NOTIFICATION level. This can be done from Enterprise Manager, or from the Weblogic scripting tool, WLST. Here, I'll show you how to do it from the command line using WLST, I think you can probably work out how to do it though EM yourself. 

So, with WLST running:

wlst> connect()
wlst> getLogLevel(logger='oracle.clickhistory.EUM')
INCIDENT_ERROR:1

The value of INCIDENT_ERROR indicates that the facility is OFF, so we can set it on with the following command:

wlst> setLogLevel(logger="oracle.clickhistory.EUM",
                  target="AdminServer",level="INFO", 
                  persist="1")

If you've not encountered the setLogLevel command in WLST before, just issue help('setLogLevel') from the WLST command line to view the options and what they mean. 

Viewing the Click History Buffer

Unlike a normal logging message we can't view the Click History output directly in EM, instead we need to explicitly dump the buffer to the console, or more usually a file.  As I mentioned we can also do this in code which is something I'll cover in another article. So for now, let's look at how to do that from WLST:

wlst>executeDump(name="odl.quicktrace", 
                 outputFile="/home/oracle/ch_dump.out")

Again you can issue the help() command in WLST for more information about the options on executeDump(), but in this case I'm just taking the simple option of dumping the data to a file.. Inside the file you'll see the output containing all of the lines of  Click History information like this:

[2013-11-20T09:08:53.332+00:00] [AdminServer] [NOTIFICATION] [] [oracle.clickhistory.EUM] 
[tid: 120][userId: alice] [ecid: 67ea61aa-dde8-4e35-afa2-a75a24c8a820-00001769,0] 
[CLICK_COMPTYPE: oracle.adf.RichShowDetailItem] [APP: SummitProductionDeploy] 
[DSID: 0000K9ohwuNFw000jzwkno1IYTfR00000X] [CLICK_VIEWID: /index] 
[CLICK_REGIONVIEWID: /customer-task-flow-definition/Customers] [CLICK_STARTTIME: 1384938532808] 
[CLICK_RENDERTYPE: oracle.adf.rich.Item] [CLICK_TYPE: disclosure] 
[CLICK_COMPCLIENTID: pt1:r1:0:sdi2] [CLICK_WINDOWID: w0] [CLICK_REGIONVIEWNAME: ] 
[CLICK_COMPDISPLAYNAME: Orders Dashboard] 

 It's pretty easy to parse this by eye...

Configuring the Click History Buffer Size

 You can view the initial size of the circular buffer by issuing the following WLST command:

wlst> listLogHandlers(name="apps-clickhistory-handler")

This will return a chunk of information, including the all important buffer size. (some information omitted here for space reasons):

Handler Name: apps-clickhistory-handler
type:         oracle.core.ojdl.logging.QuickTraceHandlerFactory
useLoggingContext: true
encoding:	    UTF-8
bufferSize:	    880640
…
flushOnDump:	    false

To change the buffer size from the value of 880640bytes it's another WLST command:

wlst> configureLogHandler(name="apps-clickhistory-handler",
                          propertyName="bufferSize",
                          propertyValue="1048576")

So that's the basics of Click History.  Next time I'll look at how to dump the buffer and use it in your application code directly. 

Thursday Oct 18, 2012

ADF Logging In Deployed Apps

Harking back to my series on using the ADF logger and the related  ADF Insider Video, I've had a couple of queries this week about using the logger from Enterprise Manager (EM). I've alluded in those previous materials to how EM can be used but it's evident that folks need a little help.  So in this article, I'll quickly look at how you can switch logging on from the EM console for an application and how you can view the output. 

Before we start I'm assuming that you have EM up and running, in my case I have a small test install of Fusion Middleware Patchset 5 with an ADF application deployed to a managed server.

Step 1 - Select your Application

In the EM navigator select the app you're interested in:


At this point you can actually bring up the context ( right mouse click) menu to jump to the logging, but let's do it another way. 

Step 2 - Open the Application Deployment Menu

At the top of the screen, underneath the application name, you'll find a drop down menu which will take you to the options to view log messages and configure logging, thus:


Step 3 - Set your Logging Levels 

Just like the log configuration within JDeveloper, we can set up transient or permanent (not recommended!) loggers here.


In this case I've filtered the class list down to just oracle.demo, and set the log level to config. You can now go away and do stuff in the app to generate log entries.

Step 4 - View the Output 

Again from the Application Deployment menu we can jump to the log viewer screen and, as I have here, start to filter down the logging output to the stuff you're interested in. 


In this case I've filtered by module name. You'll notice here that you can again look at related log messages.

Importantly, you'll also see the name of the log file that holds this message, so it you'd rather analyse the log in more detail offline, through the ODL log analyser in JDeveloper, then you can see which log to download.

About

Hawaii, Yes! Duncan has been around Oracle technology way too long but occasionally has interesting things to say. He works in the Development Tools Division at Oracle, but you guessed that right? In his spare time he contributes to the Hudson CI Server Project at Eclipse
Follow DuncanMills on Twitter

Note that comments on this blog are moderated so (1) There may be a delay before it gets published (2) I reserve the right to ignore silly questions and comment spam is not tolerated - it gets deleted so don't even bother, we all have better things to do with our lives.
However, don't be put off, I want to hear what you have to say!

Search

Archives
« April 2014
MonTueWedThuFriSatSun
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    
       
Today