Victim of Tools crashes after patching to either IP15.2/14.8 or IP15.3/14.9 ? Well you will be more than likely affected by Tools crashes while opening any script editor. So far the closest ‘workaround’ would have been to stay with Tools on IP15.1/14.7. But Oracle always (strongly) recommend compiling with the Tools release which is on-par with the patch set the enterprise is running on.

But… Although the root-cause of this bug is under triage at this moment, it came out that a temporary workaround would be to rename the file ‘samatrix.txt’ in the \bin folder.

Interesting file, looking at its contents. It lists all the VB and eScript methods for the different objects. After re-naming all seems to be in perfect order. Opening scripts editor is fine, auto-complete stills works for strong-typed objects, syntax checking is not broken and we can compile objects too. So, is their a real use for this particular file? Debatable because apparently the file in question only ships with the ‘release build’ of Siebel (which customers download), but it’s not available on in-house development environments. That is why initially reproducing the crash led nowhere ;-)

– Jeroen

In a recent article I described a new feature introduced in IP15.3 called ‘white listing’ where one could define invocations which would not lead to a reset of the SessionTimeout timer. Particularly interesting, because one could ‘white list’ the Message bar (or better call it ‘Notifications’), so that your session would nicely time-out after the configured time. Regardless whether or not you are pulling broadcast messages from the server at the fixed interval at which it is configured.

On the other side of the medal, there are these scenario’s where one would like to prevent a session time-out to occur. Typically a session time-out is configured at say 30 minutes or so. But there are always use-cases where 30 minutes in general would apply, but not in 100% of the cases.

Working with a financial services customer, an important group of their end-users complained that while writing call reports, they quite often lost their work due time-outs. How frustrating that would be, is clear. Pulling the cables and throwing your laptop of desktop out of the window (especially if it happens on Friday COB). You could try to train, and tell them to commit once and a while. But that will take a way only a percentage of the pain. And the behavior simply is damaging to the overall UX!

Trying out a simple approach, which would work in both HI and OUI – I came to the following rough-edged solution.

1. On the Applet_Load (= browser script) call a function “keepAlive()”
2. This keepAlive() function would, well, keep the session alive.

But how? The bare minimum would be just these few lines of code:

There is no magic, just a recursive function call every 5000 milliseconds. During this recursive call, the call to theApplication().GetProfileAttr() forces a server-rountrip. And it keeps your session alive. Of course, 5000 is just a sample figure. Reality, this should be a bit less than the SessionTimeout configured the eapps.cfg.

The beauty of this tiny solution, you can make it very selective. Add some little logic such that the code. Simple as that.

The same would work for both HI and OUI clients. If you have to be in an OpenUI-only environment, I would re-write it as a physical renderer instead. Leading practice: prevent leveraging traditional browser scripts. At some point in time these will be deprecated.

– Jeroen

Oracle has published on Oracle Support an update to the whitepaper “Performance Tuning Guidelines for Siebel CRM Applications on Oracle Databases“. It has more recent details on best-practices specific to Siebel implementation on Oracle 12c. Along with this update, updates to the SQL scripts for best-practice optimizer statistics collection and Siebel workload profiling have been added.

And it’s always good to refresh your memory from time to time. Reading the whitepaper again, I read about this core database feature I really did not know: “SQL Plan Management”.

Just from reading a very useful feature to take knowledge (and advantage…) of e.g. when migrating between Oracle database releases, as it can counter and mitigate risk associated with such an excise. It addresses the issue of ensuring plan stability. Although plans might change to good, the real world can be more challenging. The authors write about SQL Plan Management:

When SQL plans are required, it is strongly recommended to use SQL Plan Management (SPM) to record and evaluate the execution plans of SQL statements over time. SPM provides the ability to build baselines that are known to be efficient and that are composed of existing plans or plans imported either from other instances or previous versions. SQL plan baselines are used to maintain performance of the matching SQL statements. Over time, new plans are evaluated and preserved when their performance improvements are significant. Subsequently, these plans can be evolved to “accepted” if their performance is superior to the baseline’s SQL plan.

If you’d read a bit further, it addresses actually a broader set of scenario’s such as:

• A database upgrade that installs a new optimizer version usually results in plan changes for a small percentage of SQL statements. Most of these plan changes result in either no performance change or improvement. However, some plan changes may cause performance regressions. SQL plan baselines significantly minimize potential regressions resulting from an upgrade.

• Ongoing system and data changes can impact plans for some SQL statements, potentially causing performance regressions. SQL plan baselines help minimize performance regressions and stabilize SQL performance.

• Deployment of new application modules means introducing new SQL statements into the database. The application software may use appropriate SQL execution plans developed in a standard test configuration for the new statements. If the system configuration is significantly different from the test configuration, then the database can evolve SQL plan baselines over time to produce better performance.

I suppose I need to dive a bit deeper into this core database functionality and how well it applies to the many-many execution plans which get calculated by Oracle when running a Siebel implementation.

As said, good refresher :-)

– Jeroen

The word is out from the Mozilla blog: Firefox will de-support NPAPI Plug-ins late 2016. Mozilla following the same path as Google but with a remaining grace period of about 15 months. Although Mozilla announced it will still support Flash, Java will be a dead-end in the browser. Even though Siebel Open UI does not heavily rely on Java there are some bits and pieces which do. The most important obvious one would be the ‘inline editing’ mode of Siebel attachments. And then obviously there are customers who have resorted to a Java applet for some kind of desktop integration, replacing the traditional HI / ActiveX Web Client Automation Server capabilities to attach to a Siebel web session.

Good to know, with Innovation Pack 2016 there is a planned feature to replace current Java applet based functionality with an open Web Socket framework. Check the Innovation Pack 2016 Statement of Direction to get more details. The Web Socket framework will be open and published as API for customers to take advantage of.

– Jeroen

Oracle-Siebel’s product manager John Bedford published the official statement that SQL Anywhere will be replaced with Oracle XE (Express Edition) with the release of Siebel Innovation Pack 2015 Patch Set 5.

SQL Anywhere, being a SAP-owned product after the acquisition of Sybase in 2010 has served a long time. Especially in late 90s SQL Anywhere was considered a flag-ship product, with advanced capabilities. And Siebel has been bundling it with Siebel Remote & Siebel Tools ever since, quite successfully.

Other than the Mobile Web Client alone, Siebel Tools truly has been ‘fueled’ by this small and agile database engine. That said, being a 3rd party product – Oracle does own its own alternative: Oracle XE. Myself, I have no previous experience with Oracle XE and will be looking forward how Oracle XE will turn out as new platform for Siebel Tools and the Siebel Developer’s Web client.

What will be interesting is the fact, that Oracle XE can be connect to with SQL Developer as any other Oracle database. That surely will be much better that DBISQLC.EXE ;-)

– Jeroen

With any web application running tons of Javascript, getting track on what’s happening within the browser can be a true challenge as well as nightmare. And with the ever expanding Javascript frameworks and libraries which see the light every day, more, more and more is going on in the browser. And that is no different for Siebel OpenUI.

Recently, I got in a situation where a customer reported data loss. More specifically when sending an outbound email in reply to an inbound email. Where at the moment the user hit the ‘Send’ button, the actual email composed by the user got lost and instead an empty email was sent. Quite annoying, to say the least. More annoyingly, for the end-user: this event would go completely unnoticed. Not reproducible and with a fairly low frequency, but reported by many different users. Finding a pattern led nowhere. Since Siebel leverages the CKEDITOR library for rich text editing, this was for me one of the suspects.

I implemented a presentation model to catch the EmailSend method on the “Comm Outbound Item Form Applet New” applet, in order to get some grip on the situation. I found that by logging each and every EmailSend event through the central error logging facility exposed as business service in this implementation, that somehow in certain situations truly the data in the CKEDITOR control would be different from the data saved on the business component (and sent…). But still now clue on the “why”.

Typically a situation where you’d want to have an eye on each of the user’s browser consoles to see if any uncaught (or caught) error got reported. And especially that is a problem. Where debugging Siebel traditionally has been pretty much server-centric, the browser plays a huge role these OpenUI days.

I reckoned, I’m surely not the only one facing this challenge! Imagine you run a multi M$ or B$ eCommerce site, you surely want to have comfort and confidence that your platform runs fine on any browser or device. Assume that on Android 3.x using Firefox as browser you cannot conclude a purchase because of some unexpected error happening which no developer nor tester could have foreseen (“who runs Android 3.x with a Firefox browser”)?

It turns out there are quite some error handling frameworks out there: Sentry, Airbrake, Rollbar to name a few. And Bugsnag. Bugsnag seemed to be pretty flexible. Bugsnap is a paid service. Now one issue which might immediately come to mind: can we use such as cloud service? I agree, that might be a showstopper from a data-privacy or company policy point of view. But Bugsnag also allows for an on-premise ‘implementation’. That said, I was interested enough to give it a go. And really, working with Bugsnag is child’s play. After creating a trial account, I got it working in a matter of minutes just by adding the Bugsnag “notifier” library per Siebel manifest administration. Setting the Bugsnap API Key in the browser’s console followed by a call to the notifier’s Bugsnag.notify() and bob’s your uncle.

So that worked out pretty fine so far. And that’s interesting too, through the Bugsnag notifier you’d have an alternative for SiebelJS.Log() for situations where it would make sense. But more importantly I needed to verify whether those nasty uncaught exceptions would be be caught by the Bugsnag notifier too, which should be the core reason to use it after all. The Bugsnag notifier hacks into the window.onerror to achieve this. To test this, I just added a throw() to one of my existing customizations to simulate it.

You’d already see the exception’s trace mentions ‘_super.bugsnag’. So something’s going on!

Unfortunately, not too much detail. But at least the Bugsnag notifier logged the exception. In the next post I will explain how to integrate Bugsnag properly into Siebel and how to add more Siebel contextual details whenever an uncaught exception gets logged (or when an error is logged by code per design or for debugging needs). To eventually get something similar to this….

– Jeroen

Difficult to give this post a descent title. What this post is all about, is the fact that Siebel will ‘default’ select any text in list applet columns while tabbing through. In itself not such a bad feature. But there are situations where this behavior is by end-users perceived as highly unwanted. Think of notes, where a text area control potentially contains tons of carefully entered text. Tabbing through a list applet makes it prone to unintentionally wipe this precious and entered data at the blink of an eye (or better by almost any keystroke…).

This was brought to my attention by a customer. Luckily enough, the Siebel OpenUI offers such a great extensibility framework! Writing one of the most simplistic control plug-in wrappers ever, does the job. Goal of the plugin wrapper would be to ‘deselect’ the control’s content at the moment it receives focus. Instead of selecting the control’s value, it should just put the cursor at the far end of the text.

The plug-in wrapper is code is not more than a few basic lines, plus the standard skeleton code.

Like any control plugin-wrapper, you need to instruct it on what control type and when to act (1). I choose to have it act solely on the “SWE_CTRL_TEXTAREA” control, regardless further context – therefore the “return true;” without any further conditions. In this case we add an additional event on the control, so the BindEvents event makes most sense (2). Finally, the actually magic happens using the “focus” event, on which we trigger a single line of code to reset the selection (3). So simple, yet so powerful.

As any control plug-in wrapper, just administer as Application / Common file.

Enjoy!

– Jeroen

Continuous development, continuous integration, continuous delivery. Siebel Patch Set IP15.5 / IP14.11 has been made available. Besides an import bug fix for those running (or needing to run) Siebel on iOS 9.01 devices… this patch set has the required bug fix for the keyboard to appropriately pop-up in list applets.

Quite a download! But that sheer size has a reason.

Worth to check John Bedford’s post with regards to the enhancements (yes, enhancements in a patch set) becoming available with IP15.5. Factually, IP15.5 is an Innovation Pack in its own right. To take advantage of these enhancements, an Incremental Repository Merge procedure is required.

– Jeroen

A few weeks back I posted an initial article about my experiences with Bugsnag. On a quest to get more insight in ‘what happens in the browser’, because by and large ‘what happens in the browser, stays in the browser’ I bumped into this neat tool. In this space of error reporting and incident management tools, alternatives exists such as Airbrake, Sentry, Rollbar and Raygun to name a few. I choose for a proof of concept Bugsnag because it appeared to be simple to integrate as well as it’s offered as 100% free trial.

Deploying complex web applications such as Siebel which are built on top of a bundled set of libraries such as JQuery, RequireJS and CKEditor poses a real challenge. Add the diversity of browsers in the mix, and you have a nice cocktail. Just the believe that functionality will work cross-browser is an utopia. Gaining the insight in ‘what happens in the browser’ can be considered a must-have, especially in a diverse environment where Siebel is exposed on different browsers, platforms, devices, in managed desktop environments or to users in the uncontrolled big, bad, world out there.

Setting up your trial account with Bugsnag requires just a few clicks. In return you will be provided an API key and access to your own Bugsnag dashoard.

The Bugsnag ‘notifier’ library is available to be integrated in any web application. Integrating it with Siebel turned out to be extremely simple. Just adding the library as ‘Application’ / ‘Common’ did the job. Setting the apiKey followed by invoking the notify() function in the console is enough to test the essentials.

Bugsnag.apiKey = “d31fd6cda4a46a9f4e251207c8xxxxxx”;

Bugsnag.notify(“SBL-ERR-BUGSNAG”, “Log this error”);

Logging onto your Bugsnag dashboard should show within the blink of an eye the error!

Nice. But we need to do better!

When Bugsnag intercepts an uncaught exception, it would be useful to have some contextual information being sent alongside the call stack, won’t it? For that particular purpose, the Bugsnag API allows to add ‘meta data’ by using the ‘beforeNotify’ function.

I ended up with a straight-forward piece of code, which loads as Application / Common file.

1. It creates a new class ‘SiebelBugSnagNotifier’
2. Next it creates a dependency on the Bugsnag Javascript API (‘bugsnag-2.min.js’)
3. Following the apiKey is set (I opted for sake of simplicity to hard-code the key…)
4. Next the beforeNotify() function is implemented
5. The ‘metaData’ and ‘user’ JSON objects are populated with contextual information. Other than essential static details such as Login Name, User Responsibilities, View Name & Title – I added also the raw data (if available) from the applet which had focus the moment the exception got caught.

Now, what happens when I on-purpose generate an uncaught exception? Well, first of all we get a nice call stack leading quickly to the error. And yes, I made a type calling ‘setTimeout’ in the /siebel/custom/CheckCommitPendingPR.js!

Further, the view context gets provided…

As well as the raw data…

And the logged in user details too…

All together, quite happy with the end-result. And other than logging uncaught exceptions, calling Bugsnag.notify() anywhere in your code, could be an alternative for SiebelJS.Log(). But use it sparsely in that case, since it will definitely incur overhead. And we do not want to slow-down Siebel, do we?

You can grab the code here. If you have thoughts, let me know.

– Jeroen

I’m sure if the team at the SiebelHub would in their series of ‘snap polls‘ start another poll soliciting for the top most UX ‘inconveniences’ with Siebel OpenUI, will find among the higher ranking  issues the fact that the ‘back button’ should be used with great care.

Great care, because any uncommitted data will be gone, forever. Have you just spent half an hour on a lengthy call report? The back button will not commit it for you, rather will throw it away… This very issue comes up again and again.

Although there is no water-tight solution, I have been testing a feasible approach using the undocumented method ‘IsCommitPending’. I found that this method of the business component class tells you whether there is in-flight data.

Just entering following on the browser’s console will tell you, if you have in-flight data:

SiebelApp.S_App.GetActiveView().GetActiveApplet().GetBusComp().IsCommitPending();

That’s actually a pretty cool framework feature, though… undocumented (hence it might change, and don’t try to ask Oracle tech support to provide further guidance…)

The IsCommitPending() returns a consistent output. Once you change any data, it will return ‘true’. The moment you either explicitly commit the data using CTRL+S or the applet menu ‘Save Record’, instantaneously IsCommitPending() will return ‘false’. Also stepping of a record, will implicitly commit the data, hence IsCommitPending() will return ‘false’ too.

So, I marched on. I created a simple applet presentation model as proof of concept to capture all ‘FieldChange’ events. On the first ‘FieldChange’ event I create a floating div with the id=datalossWarning and the default class ‘dataloss-warning-disabled’.

Per CSS pseudo-selector I add a font from the ‘oracle’ font, to serve as indicator.

I further attach a click event, which as part of this proof of concept I added to the presentation model as well. But rather, this should belong in a physical renderer instead… And rather than using the JQuery’s click event, it would be more appropriate to use the Helper class to make behavior consistent across non-touch and touch devices. But that is all for later!

Once the visual check box indicator appears, clicking the same will execute a write record as such:

SiebelApp.S_App.GetActiveView().GetActiveApplet().InvokeMethod(“WriteRecord”);

I choose to make it fade away using a simple transition. The CSS is as simple as effective.

The most relevant lines from the presentation model are presented below. Again, a setTimeout was required to ensure the code to be executed after all other framework code completed. Required to have the IsCommitPending() call to  return the correct value. Inspecting the value, drives simply swapping the CSS class from ‘dataloss-warning-disabled’ to ‘dataloss-warning-enabled’ or vice versa.

The complete presentation model ‘CheckCommitPendingPM’ code for a list applet, is not more than a few lines besides the typical framework code required for any presentation model. I choose to use the ‘Init’ event, but likely the ‘Setup’ would have worked as well. Not sure if there is a benefit for either.

I further added a few lines in my existing post loader, to remove the #datalossWarning div every time a new views loads.

A brief demonstration puts the cherry on the cake:

Again, this is a proof of concept. Interested to hear feedback :-)

As from previous readings, you might know that enabling this across the application is due a current framework limitation not that straightforward without possible breaking out of the box functionality. Simply overriding the ‘DEFAULT LIST APPLET’ presentation model, will due to the sequence in which the OpenUI framework loads code will prevent a possible out of the box presentation model to load. So be careful there!

–  Jeroen

No need to explain that these infamous two words hide worlds of potential causes, if you happen to run a Siebel implementation. I got involved in a situation at one of my customers, where end-users were reporting end-less occurrences on the above mentioned. User’s reported to be kicked-out for no reason, often loosing in-flight data while having a customer on-call. The volume of reports was more than substantial, though initially real, objective measured figures were not available.

First and foremost focus in such situation should always be: are there any frequent object manager crashes? Unfortunately customer was not running the Server Task Persistence component, part of the Siebel Failure Diagnostics Framework which got introduced as part of Innovation Pack 2012. This out-of-the-box feature helps administrators analyzing crashes, and viewing key characteristics ‘comfortable’ from within the Siebel UI. So without going through the laborious process grabbing manually the call stack from the /bin directory and decoding the FDR files. Added ‘bonus’ is that you immediately know which users got affected by a specific crash.

Luckily, the background utility ‘siebprocdiag’ used by the Server Task Persistence component to gather the key details, can be also be run manually on a specific server using. Siebprocdiag will essentially cycle through all available .fdr files, decode them and relate them back to call stacks reported in the crash.txt file. The way in which siebprocdiag reports the results of its FDR analysis can be solid gold. It reports in the form of “user navigated to view ‘x’, invoked method ‘y’ on applet ‘z’ which in turn invoked business service ‘abc’ leading to a crash”.

Detailed output will be:

• Siebel Server and server component names
• Time of failure
• Process, thread, and task IDs
• Number of affected tasks
• Last set of meaningful business processes that occurred at the time of the failure
• Whether a new process was created, and if so, the list of current users impacted by the failure
• A list of users whose sessions were lost following the failure
• Content of the actual crash.txt file that was logged, which provides the call stack, register contents, and memory information

Well all said and done, we figured out there were crashes and a good number of them across all four Windows servers hosting Call center object managers. The use of siebprocdiag proved vital in quick root-cause analysis, it turned out a buggy business component definition leading to incomplete SQL statements being generated, that business component got introduced in the most recent SRF release.

But guess what, after all the object manager crashes ceased to exists after an emergency release – users kept reporting ‘server busy’. What was going on?

We started to increase ‘EventContext’ tracing, to get a better grip and to hopefully see some type of pattern. Unfortunately, that lead nowhere.

One step further we added ObjMgrSessionLog=5 and ProcessRequest=5 in order to trail the flow of events. At the same time we cranked-up SWSE monitoring per three usual system environment variables (SIEBEL_LOG_EVENTS = 4, SIEBEL_SESSMGR_TRACE = 1, SIEBEL_SISNAPI_TRACE = 1). Although SWSE tracing is flooded with irrelevant (no, what I mean is ‘benign’) traces, it typically can be well filtered based on SARM ID which can always correlate an Object manager task with SWSE tracing.

The SARM ID is printed in every line of a component log. The fact it correlated with SWSE tracing.

TaskConfig    TaskCfgParamInit    3    0000003c56710e30:0    2015-12-30 15:28:14    The Parameters for the current task (8405474) are :

Since the customer is running a high-available configuration including a set of hardware load-balanced web servers, we decided to temporarily by-pass the load-balancer. Luckily the vast majority of end-users are on Citrix, hence we able to provision a changed short-cut instantaneously. By-passing the load balancer we both could cancel-out the load-balancer  being potential culprit as well as analysing is simply easier on a single web server. Load-wise it should create no issue to run on a single leg temporarily.

Run a couple of hours, the incidents kept flowing in and pretty quickly we noticed this pattern:

ObjMgrSessionLog    ObjMgrLogin    3    00005710566f096c:0    2015-12-30 15:43:38    Username: XYZ, Login Status: Attempt,  Session Id: bP6I.5OZwhK.IxZSBDlRU3dYBTdk2UeLUkP8fk83cyQcXmEKcPnGWD4mUAYLDnQCtsMEDoCp8E6aDkhoXWRCgX-4QnqEWCECWJHyMZKAcVqMF6MI1szESLb78y05d7O-SIO8bmbJ2W5SFgJvqj8kD-V1Gx.zFc4hjxWshoKQSlg_, IP Address: xx.xx.xx.xx

Usually, if you spot “Login Status: Attempt” in the middle of a web session, it simply means a time-out. But under normal circumstances, the message in the log should be preceded by “SBL-SMI-00126: The session has timed out”. The “Login Status: Attempt” message, would in case of WebSSO ensure the user is logged-in automatically, after a session timout. Moreover, in case of a traditional time-out, you should be easily able to spot a gap in the log corresponding the the SessionTimeout configured on the web server (eapps.cfg).

After collecting during a good deal of a day we confirmed a couple of things:

1. The message “Login Status: Attempt” (if not preceded by SBL-SMI-00126) clearly indicated a an ‘affected user’.
2. Extrapolating on the occurrences we collected over the period of one hour on one single server, we found the issue to hit approximately every users two times their working day. Wow.

But the most intriguing fact: at the same time, groups of users got affected. Sometimes a little as 2, sometimes as many as 9. And these groups of users were always related to one specific object manger process Id.

This latter piece of information led us to believe a relationship with SISNAPI session multiplexing between SWSE and Siebel Servers. The SWSE multiplexes Siebel web client session over a pool of SISNAPI – which of course are just TCP/IP – connections. SWSE maintains a ‘pool’ of SISNAPI connections for each target object manager process. Multiplexing is defined by the SessPerSisn value on the object manager, and defaults to 20. The size of the pool is calculated by:

Max Tasks of the component / Max number of Object Manager multi-threads processes / SessPerSisn. This figure should lead to an integer value. So take Max Tasks = 200, MaxMTServers = 5 and the default SessPerSisn = 20 would lead to 2 SISNAPI connections for each multi-threaded process. I have to admit, in the past 15+ years I have never been required to tweak this value.

We verified these connections running “netstat -ano | find “2321”. The output contains a trailing column a PID, this PID related to the SiebService process on the target Siebel server. So basically you separate the output, and confirm the number of TCP/IP connections between SWSE and a particular Siebel Server.

netstat -ano | find “2131”
  TCP    53.53.53.29:2321      53.53.53.193:52207    ESTABLISHED     3464
  TCP    53.53.53.29:2321      53.53.53.193:52458    ESTABLISHED     3464
  TCP    53.53.53.29:2321      53.53.53.193:52680    ESTABLISHED     3464
  TCP    53.53.53.29:2321      53.53.53.193:52736    ESTABLISHED     3464

Anyways, working with the network team we ran a short while Wireshark between the SWSE and one specific Siebel Server. And since we could indicate second-close when an incident produced itself, Wireshark data could be filtered appropriately without being overwhelmed. And guess what? Spot-on, we found a match. It appeared that the Web server closed a TCP/IP connection with details: [RST, ACK, CWR]. The network team immediately noticed the uncommon “CWR” flag which was set on the Reset (RST) packet. CWR means ‘congestion window reduced’, which essentially is a mechanism for a sender to re-negotiate the window in which packets are being exchanged with the receiving party, to make it smaller because of perceived packet-loss or congestion.

A bit more details here, is that CWR has a related feature named ‘Explicit Congestion Notification’ or ECN. And interestingly, ECN is a feature which on Windows releases prior to Windows 2012 has been available, but default it has been always disabled. But with Windows 2012 the feature has been enabled by default. Since the network and infrastructure teams were not prone, disabling ECN because they felt the applications should be resilient we considered changing SessPerSisn.

Theoretically: lowering SessPerSisn would increase the number of SISNAPI connections, and likely lowering the possibility of congestion on one specific TCP/IP connections. At the same time, we would be reducing the number of users impacted. Side-effect of lowering SessPerSisn would be increased memory foot-print for the SWSE plugin plus additional OS memory overhead for both Web servers as well as Siebel Servers. Additional memory for the SWSE plugin should be approximately 1 Mb / SISNAPI connection. Additional OS memory was estimate to be 100 KB / connection. In the customer’s setup that would not accumulate to huge figures.

Decision was made to lower SessPerSisn from default ’20’ to ’10’ – so basically doubling the number of TCP/IP connections. The change got implemented, and seems to have the looked-for effect. The ‘Server Busy’ messages have not been seen anymore!

Now – the story is not over and done for me. Some questions need still to be answered from Oracle’s side:

1. Should we recommend other values for SessPerSisn for Windows 2012+ implementations?
2. How to effectively ‘measure’ what an appropriate value for SessPerSisn should be. It’s appreciated that doubling the number of SISNAPI connections seems to work, but it would be good if it could be pro-actively monitored when congestion lingers.

– Jeroen

The 2016 SOD already mentioned a totally new Siebel acronym. Because running out of three-letter-acronyms, resorting to four-letter acronyms ;-)

DISA.

The SOD also mentioned backporting the DISA framework to IP14/15. And that seems to materialize. Although it definitely slipped the December 2015 Patchset (14.13/15.7) for which it was initially targeted – the odds are that it will quite likely make it into the January 2016 Patchset (14.14/15.8).

So again, what’s this Desktop Integration Siebel Agent all about? Well, first of all it’s the must-have feature closing the important Siebel client-side integration gap. Especially because Google started deprecating the NPAPI in Chrome, Mozilla will follow deprecating NPAPI in Firefox later in 2016 and Microsoft’s Edge never had and never will have the capability.

DISA will be all about bringing Siebel OpenUI on-par with the old ‘high interactivity’ days where the Web Client Automation Server was a strong asset, enabling relatively easy client-side integrations with desktop applications and a Siebel user session.

DISA will be a local client-side running executable, which means it will only be available for Windows clients. The DISA will act as a Websocket-server, and because today all of the relevant browsers will support the Websocket protocol,  browsers running a Siebel OpenUI session can act as a Websocket-client. The framework will enable bi-directional, real-time communications between browsers.

Unsure whether at the time DISA will be released as backport from the under-development IP16 codeline is which of the features will be enabled alongside? I personally expect that initially the DISA framework as-is will be released, and that out-of-the-box enhancements such as listed below will be released gradually in subsequent patchsets.

DISA targeted features:

» Email (F9) Integration with Microsoft Outlook and IBM Lotus Notes
» Invoke external email clients with F9 on Siebel Open UI
» Populate email fields (To, CC, BCC) in external email clients
» Use HTML templates to provide pre-defined, formatted email content
» Send file attachments
» Read & write files in agent’s local machines
» CTI Hoteling feature
» Ability to retrieve client machine IP address in Siebel Open UI Client
» Outlook to Siebel Attachment Drag-and-Drop. Enables agents to drag an email from a Microsoft Outlook email client and drop it as a Siebel CRM file attachment
» Inline attachment editing. Provides the capability for a user to open a file stored in the Siebel File System, make changes to the document using a location application (such as Microsoft Word), and then save and close the application with the new version automatically replacing the previous version in the Siebel File System.
» Batch Fulfillment Printing
» Allows Fulfillment Center personnel to select a set of Correspondence Requests and send them to a printer.

– Jeroen

The December Patchset slipped a couple of days into 2016, likely due to the holiday season. But here it it. Patch numbers are respectively 22392806 (IP15) and 22387952 (IP14).

Wading through the release notes I stumbled into this bug, drawing my immediate interest:

Bug 1931733: OPEN USER INTERFACE: WHEN YOU USE THE SHOW MORE OR SHOW LESS OPTION IN THE LIST APPLET, IT CAUSES DATA LOSS.

Checking on the reproduction steps, it becomes apparent that it’s a rather simple scenario resulting in a very undesirable result:

(1) Login to Open UI client.
(2) Go to [Accounts]->[Accounts List]
(3) Create records or run a query so the list applet has 11 records.
(4) Place the focus on Name field on any record.
(5) Click 'Show More' icon to see the all 11 records.
(6) Click 'Show Less' icon to see the 1st 10 records.
(7) Click 'Next record set' icon to show the 11th record.
(8) Now you see that the 10th record show the 11th record's data.
(9) Click 'Previous record' icon 10 times to navigate the records upward one by one.
(10) You will see that Name field data on several records are modified and saved to the database. The original data is gone. The issue occurs when the list applet has more than 10 records and less than 20 records.

Happy this one got identified and fixed! If one thing can be more UX-damaging, it would be data loss.

One other Bug to mention:

Bug 2313035: CRASHES SEEN WITH NEW STENGINE MEMORY MANAGEMENT LIBRARY

This is related with the in IP15.4 / IP14.10 implemented ST Script engine performance improvements, primarily focused on more efficient memory use. This fix can be optionally enabled using the USE_NEW_RM = 1 / USE_NEW_MM = 1 environment variables.

– Jeroen

Chances are that you have used or even are a frequent user of Duncan Ford‘s boilerplate code generator for Siebel OpenUI. His boilerplate code generator surely is the safest and most effective way to start any undertaking comprising a custom presentation model, physical renderer or control plug-in wrapper. It prevents you from those silly typo’s which can easily waste your time. All together, a huge efficiency tool.

Well, Duncan decided to move his code from JSFiddle to Github. For a very good reason of course. This move permits those with ideas for improvements to add them directly to Github’s managed issues log, and, for those more skilled, to allow to directly submit pull-requests with changes made. Which Duncan then will be able to test and decide upon

Although the existing tiny.cc URLs which you might or might not have bookmarked, have been changed by Duncan as well to reflect the new location. Below the direct Github URLs.

• Presentation Model & Physical Renderer Generator
• Control Plug-in Wrapper Generator

– Jeroen

(Click the image to follow the URL)

Not gracefully logging out of Siebel is one of those user habits which is hard to kill. Especially because in the high-interactivity days, closing the browser would gracefully end the Siebel session on the server. Well… that changed with the OpenUI client because there is no way in which the browser ‘X’ button to either close a tab or the browser all together can be intercepted (similarly for the back button).

End result: having potentially many orphan sessions, waiting until the session times-out. Well, that can be considered still a positive scenario: the session will time-out. But might you have message broadcasting enabled, it won’t. Unless, again, you take preventive measures explained in this post about white-listing certain events.

But another, yet worse scenario to happen is that an user has uncommitted data, pending to be committed. What will happen using the ‘X’ approach? You can guess what, you will loose whatever is pending. Likely that it happens? Sure! And this will hurt your user adoption and creates frustration among the user base, guaranteed. The same obviously goes for that so-often used back button, that set aside.

In a previous post I discussed one possible approach, indicating users they have unsaved data. I’m about to write a post, with an alternative solution for the same issue. Keep a close eye on the blog :-)

But back to logout. I firmly believe the standard’s theme ‘logout option’ hidden behind the ‘user’ button, is, well, too much hidden. The same goes for the logout option in the application menu. So I decided (and others will have done similar, for sure) to add the logout button where everybody would expect such a button: top-right corner or the browser’s window.

Added a tiny bit of additional functionality:

a) Greying-out the background
b) Enabling the spinning Siebel wheel ‘busy’ cursor

I decided to keep it purely an image (or better: glyph), to prevent any localization. If I’d have opted for a ‘logout’ text (either with our without the glyph), I would rather have created the logout button through Siebel Tools, leveraging translation through a symbolic string. Changing the behavior (e.g. moving it to the far-right and adding the logout code, would then still be done client-side by javascript plus CSS).

Here I decided to generate the button during postload, with some basic CSS. You can simply add this code to your existing postload. Otherwise, you need to create one.

I created the CSS for Aurora. Technically it does work for the Synergy theme. You just need to tweak the CSS a bit more.

Enjoy!

– Jeroen

Siebel IP15.8/14.14 arrived, per scheduled date. The traditional document to keep a close eye on “Oracle Support Document 1614310.1 (Siebel Patchset Installation Guides for Siebel Innovation Packs)” has been updated as well. Unfortunately, the awaited “Desktop Integration Siebel Agent (DISA)” framework solution has been pushed into the February patchset IP15.9/14.15.

There are a couple of bugs to mention here:

• Bug 2132644 – IN THE ANDROID TABLET BROWSER, THE KEYBOARD POPS UP WHEN YOU CLICK ON THE NEXT RECORD BUTTON IN THE FORM.
• Bug 22327858 – UNABLE TO UPDATE THE VALUE OF THE CHECK BOX IN THE ANDROID TABLET BROWSER.
• Bug 22158305 – WHEN YOU ENTER THE DATE USING THE KEYBOARD THERE IS DATA LOSS IN THE OPEN USER INTERFACE.
• Bug 22447460 – THE BC USER PROPERTY “FIELD READ ONLY FIELD” IS NOT WORKING CORRECTLY.
• Bug 22447602 – TOGGLE APPLETS ARE NOT SWITCHED WHEN A PDQ IS EXECUTED.

– Jeroen

On the leap day of February, IP15.9/14.15 has been released. Set aside a number of fixes, the long-awaited DISA (Desktop Integration Siebel Agent) framework has been released! And Outlook Drag-n-drop becomes reality, again.

Desktop Integration Siebel Agent

DISA has been previously discussed by Alex and myself in the recent past. The DISA framework will support with IP15.9/14.15 the below two features:

1. Inline file attachment editing
2. CTI Hoteling

But essentially, DISA will be a framework to support further future features, as well as allow custom-built desktop integrations. At some point.When at some point will be, is unknown at the time of writing.

Note: in the past it was communicated that the Siebel Outlook Drag-n-Drop feature (SODD) would also leverage the DISA framework. But after many considerations, the SODD feature (also part of IP15.9/14.15) will use a separate Outlook Add-in.

Reading the DISA release notes seem to imply that Incremental Repository Merge is required to take benefit of DISA. That is factually false.

Detailed instruction can be found is this fresh-from-the-press MOS Document:Oracle Support Document 2107511.1 (Install and Deploy Desktop Integration Siebel Agent (DISA)). There are just a few manual configuration steps required as the DocId mentions. More importantly, DISA does require a local client-side installation. Can be ran and provisioned as silent installer. Something to take note of, it can be obvious hurdle. There is a current limitation that the DISA installer is only available in English, but that does not affect the functionality in a multi-lingual implementation however.

Special set-up activities are required for both Firefox and Edge. The installer supports silent installation, using a response file. And DISA supports the needed security features, such as server/port white-listing and security certificates to allow secure communications.

Microsoft Outlook to Siebel Drag-and-Drop (SODD)

The SODD feature will rely on a specific Outlook add-in. Now I hear you think, that will be a challenge to get across within IT. Anyways, if SODD is a looked-for feature, options are limited especially due to the NPAPI deprecation. Still on IE11? In that case you could craft your own Java-applet based solution (it has been done before).

Well, what are the the use cases supported for SODD?

• Drag one email from Outlook and drop it on Siebel, the attachment will be saved accordingly, context sensitive.
• Drag multiple emails at one time from Outlook and drop them to Siebel. The emails will be saved as multiple attachments, context sensitive.
• Drag email attachment(s) from Outlook and drop them to Siebel. The email attachments will be saved as (multiple) attachment(s), context sensitive.

All together IP15.9/14.15 is not just a patch set :-)

– Jeroen

About two weeks back I posted an article on LinkedIn under the same title. It generated a bit off buzz based on feedback I received. The use-cases one could imagine having this feature are endless, if you ask me. If you haven’t seen it yet, check the Youtube footage.

The original idea was drafted by Warren Mull, and I took the raw demo solution to the next step. Why? Because as said, there are endless use-cases and a feature alike has been requested for as long as I have been working with Siebel.

Traditional solution would be to allow multiple Siebel sessions to be opened by end-users, which really, is one of the worst approaches possible for many reasons. The beauty of the Pinnable Views is the fact, that there is no Siebel session tied to it. It acts as a ‘static’ copy or clone if you wish of the original Siebel view. That does mean, the Pinnable View does not allow any further user-interaction (no drill-downs, no navigation, no scrolling). But for the majority of the use-cases, that is no limitation if at all.

So, this post is all about the implementation. Which really, is quite straight-forward. Conceptually it consists of just a few steps:

1. A postloader injects the necessary code to display the ‘pin’ and ‘unpin’ buttons;
2. When the ‘pin’ button is clicked, it will traverse the DOM’s <head> to identify all the embedded CSS stylesheets. That would allow, to reference these same stylesheets in the ‘cloned’ page;
3. Retrieving the view’s current title (from the <head> section);
4. Create a boiler plate HTML document, referencing the previously collected style sheets and page title;
5. Generate a new window, which would display as a tab in the browser;
6. Cloning the existing view’s ‘_swecontent’ into the new window’s document;
7. Push the new windows handle to an array, within the scope of the Siebel application.

No more, no less.

And sure, a bit of additional styling is requires to visualize the ‘siebel-pin’ and ‘siebel-unpin’ glyphs nicely. And about these glyphs: I desired to have a decent ‘unpin’ glyph. But that is non-existent in the fonts delivered with the application. So I choose to create a separate ‘siebelpins’ font-family for that purpose. In a previous article I explained how to go about, creating a new font-family using icomoon.

But this time, I just wanted to create a custom glyph. Not from scratch, but based on the existing ‘pin’ available in the ‘oracle’ font-family, delivered with the Siebel application. So how to go about?

First, you need to get a decent ‘path’ or ‘polygon’ svg. That is easily done with the Icomoon app. Simply import the ‘oracle.svg’ into Icomoon, select the ‘pin’ glyph and have Icomoon generate your font.

It will something be alike shown below. But do not worry, you don’t need to understand what SVG is all about😉

Next I turned to Glyphrstudio, which is a really neat tool to create either from scratch or modify any existing font. As long as you have a path or polygon SVG string available, you’re fine. Simply copy/paste your SVG string and voilá – there you go.

Glyphrstudio provides a neat editor, so just drawing a diagonal line through the ‘pin’ glyph takes little time.

The next step would be exporting your new SVG font. Because we would like to have .svg, .woff, .ttf and .eot representations of the the new font, it’s back to Icomoon again. Import the SVG generated by Glyphrstudio, and save it again. Icomoon will generate a .zip archive with all the goodies inside.

The resulting files .svg, .ttf, .woff and .eot files you can copy to your Siebel’s /public/<lang>/fonts/custom folder.

Alright, so what would need to do code-wise? Let’s walk you through.

It generates a ‘windowsPopups’ array, which will hold any handle to Pinnable Views windows. Why? Well, because otherwise we cannot close them.

Next the buttons get appended to the application menu (if you happen to use the Synergy theme, sure you need to visualize the application menu, or append the buttons to another element).

Forcing to re-paint is required, otherwise the buttons will on initial display be ‘wrapped’ and not shown as a single block.

Next, we define the ‘onclick’ event. The first reference we add is the ‘faviconpin.ico’ which I created. Next it traverses the style sheets, and appends these. Finally the <heads>  title is retrieved. The boiler plate HTML is created, the new window is generated and the boiler plate gets written to it. The ‘_swecontent’ portion of the view is cloned, and finally we push the handle to the earlier mentioned array.

To make things a bit more appealing, adding hover functionality. Implementing the ‘unpin’ is as simple as closing all of the windows while looping through the array.

To suppress any non-sense elements on the pinned view, I added a bit of styling to the pinnable view. Remember, that in the first stage I embedded a popup.css?

And this is the tiny bit of content.

Lastly, the needed additions to your theme override. First define the new font-famile ‘siebelpins’ (usually on top of your CSS). Beware that the paths are considered relative from where the override CSS is located. That should be in /files/custom – but if you decided otherwise beware of that.

That it. And of course, you can grab it all here:

• Pinnable views postloader code
• Pinnable views Favicon
• Pinnable views button CSS
• Pinnable views popup CSS
• Pinnable views fonts archive

Enjoy!

– Jeroen

Scheduled per usual end-of-the-month, IP15.10/14.16 has arrived!

Most remarkable, the CTI “Web Notifications” feature, originally expected for IP16 has been introduced as part of this patch set.

Bug 22636162 “CTI – ADD A WEB NOTIFICATION WHEN SIEBEL NEED AGENT’S ATTENTION”

In those far away (?) high-interactivity days, on an incoming call – the Siebel window would be brought to the front. With OpenUI that feature ceased to exist, because simply impossible. But as also Neel mentioned in his post, Web Notifications can be considered the modern like-for-like feature.

Chrome and Firefox natively support Web Notifications. For Internet Explorer, you need to install a plug-in. Clicking on the Web Notification will in Firefox and Chrome direct you to the the right browser’s tab. For IE, it depends. Signs are such that if you have multiple IE tabs open, it will not be able to focus the Siebel tab.

– Jeroen