Instant Technologies - Solutions for Lotus Sametime, Microsoft OCS, and Enteprise IM

Web Client for Microsoft Lync 2010

noreply@blogger.com (Instant) — Fri, 25 May 2012 17:25:00 +0000

This week, we have spent some time exploring options to provide a web client for Microsoft Lync 2010. As we started to explore this area, we anticipated that we would simply use a Lync web client SDK from Microsoft. However, with Lync 2010, there is no default web client or web client SDK.

So, we have explored a few options during this assessment

Leverage the Lync web client that can be configured to run as part of an Exchange 2010 OWA deployment
Deploy an internal web client proxy service that uses the UCMA api and a custom web client
Integrate with the name.dll component that is installed as part of a Lync 2010 client installation

Initially, we thought that we might be able to extend, and possibly use, the Lync web client that is provisioned as part of a Microsoft Office 365 configuration. Apparently, this web client can also be configured as an extension to an Exchange 2010 installation with the addition of the OWA and OCS 2007 R2 web client installation. After some low level investigation with Fiddler we decided that a more structured, and open, approach would be better option.

Here is the Office 365 Lync client:

Here is a link to a good article on integrating Lync and Exchange: http://blog.schertz.name/2010/11/lync-and-exchange-im-integration/

While the integration provided with the Exchange 2010 OWA looked promising, it was a bit too heavy for what we wanted. So, we continued our investigation and located a few promising projects on Codeplex.

Specifically, this Codeplex project is very interesting:
http://lyncwidget.codeplex.com/

This project provided a nice base platform for developing a customized web client for Lync 2010. After a bit of work, and some modifications on our side, we had a nice looking web client for Lync 2010.

In terms of our modifications, we externalized some of the configuration - to allow for manually configuring the Lync server details. We also migrated the Lync end point from using application end point to an end point that acts as a simulated SIP user. We typically experience a high level of success (mostly with presence based API calls) when we use a end user end point - as opposed to the application end point.

Here is the presence example on a page:

Starting a chat:

With the Lync client on the other side of the conversation:

Our next steps will focus on some additional wiring to pass the end user's credentials to the the client (using Windows pass thru authentication) as well as some other configuration options.

Detecting presence of a local Lync client

Another interesting facet of a web-based Lync client, is that we are able to detect whether a Lync client is already running on a user's desktop, and if it is, rather than surfacing a web-based Lync client, we could bring up the users native Lync client running locally on their desktop. There are a few requirements for this functionality:

Internet Explorer must be used when navigating the site. It's the only way to interface with the necessary DLLs to call the local Lync client.
Office 2007 or 2010 must be installed. This places down the proper Lync presence/integration DLLs for us to use through the web.
Lync client must be installed (running too if you expect to get the Lync client and not the web client).

We'll be using JavaScript to perform these tasks, and to get a basic example, it's really minimal code. First, let's make a simple JavaScript library that we can use to access some functions from the name.dll that we'll be manipulating for Lync.

var Instant = {
    sipUri: "eric_lync@instant.local", // Change this to the user's SIP URI you want to chat with
    nameCtl: new ActiveXObject('Name.NameCtrl.1'),

    onStatusChange: function (name, status, id) {
        alert(name + ", " + status + ", " + id);
    },

    showOOUI: function () {
        Instant.nameCtl.ShowOOUI(Instant.sipUri, 0, 15, 15);
    },

    hideOOUI: function () {
        Instant.nameCtl.HideOOUI();
    }
}

Our code here builds an object called nameCtl out of the name.dll NameCtrl control that is enabled with Lync and Office 2007+. This object opens up some other properties and functions that we can use to show information about the user, and track status. Our 'onStatusChange' function tracks a user's presence, it polls for the users current settings, and alerts it. The 'showOOUI' function will show an interactive display when called (more on that in a bit) and the hideOOUI function removes it. Let's build a page now that we can use to test our library.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Lync Presence Test</title>
    
    <!-- le JS -->
    <script type="text/javascript" src="assets/js/instant-presence-0.0.1.js"></script>
    <script type="text/javascript">
        if (Instant.nameCtl.PresenceEnabled) {
            Instant.nameCtl.OnStatusChange = Instant.onStatusChange;
            Instant.nameCtl.GetStatus(Instant.sipUri, "1");
        }
    </script>
</head>
<body>
<span onmouseover="Instant.showOOUI()" onmouseout="Instant.hideOOUI()" style="border-style:solid;">Eric Richards</span>
</body>
</html>

Our page above includes our JavaScript library (instant-presence-0.0.1.js, in this case), and includes a span with some onmouseover and onmouseout functions that will get called from our library. When the page loads, we reference Instant.nameCtl.PresenceEnabled, which checks to see if the Lync client is currently running, if it is, we start checking status with Instant.onStatusChange. Now if we were to hover over the span, we would see a full Lync menu like the screenshot below.

From this menu, we can chat, call, video call, meet, etc. We have the full capacity of the local Lync client, all with just a few lines of HTML/JavaScript!

Getting the availability of a Queue using JavaScript

noreply@blogger.com (Instant) — Fri, 25 May 2012 13:25:00 +0000

When utilizing Queue Manager as a click-to-chat platform, it's important to be able to accurately know the current state of the Queue. You wouldn't want end-users trying to chat if the queue was offline, this would lead to user disappointment and dissatisfaction. You also may want a way of displaying how many experts are currently online, available, and ready to chat, to show the strength of your 'support-force'. Our Queue front-end has had support for these sort of requests for sometime, but in our most recent release, we've made these activities easier to perform. Let me walk you through a typical scenario, and I'll show you how easy it is.

Scenario: You want to check the status of the queue on a simple web page button press.

To achieve this functionality, we'll do a few things in JavaScript, but the code itself is very straightforward. To do this we'll be using the following (new!) Queue Manager API call to get the status of the queue:

http://<FQDN of Queue Manager Server>/ITFramework/webclient?getSTStatus=<Queue-Login-ID>

Replace the fields necessary with your environment, the Queue login ID would be something like 'Demo Support' or 'support@instant-tech.com' depending on how the Queues are set up in your deployment.

We'll make a simple JavaScript call to call this, and return the Queue status. The function below shows how the code would look to perform this task. It's a mixture of JavaScript and jQuery, so you'd need to make sure the page you are testing with is using jQuery for this example to work.

var Instant = {
    getQueueStatus: function (queueID) {
        var url = "http://192.168.1.214:8080/ITFramework/webclient?getSTStatus=" + queueID;
        
        $.ajax({
            url: url,
            type: "GET",
            complete: function(result){
                status = $.trim(result.responseText);
                if (status === "na") {
                    console.log("Queue is offline, or doesn't exist."); // Log the message out to the Chrome/Firefox/Firebug console
                }
                else if (status === "STATUS_ACTIVE") {
                    console.log("Queue is online."); // Log the message out to the Chrome/Firefox/Firebug console
                }
                else if (status === "STATUS_AWAY") {
                    console.log("Queue is unavailable. All experts are unavailable/offline."); // Log the message out to the Chrome/Firefox/Firebug console
                }
                else {
                    console.log("Queue may be available, check it's status in Sametime."); // Log the message out to the Chrome/Firefox/Firebug console
            }              
        });
    }
}

In the code above, we've created a function getQueueStatus inside our Instant object that takes the Queue ID as a parameter. We build a 'url' variable with the FQDN to our Queue Server, and the Queue ID that we passed in. Once we have that, we do a simple AJAX GET request to the url variable we built. Once we get the response, our code with run through the 'complete:' section of our code and it will assess what the server has returned. We use jQuery's $.trim() function to strip any '\n' line breaks that may be returned with the data. The API call could return up to 12 responses, but we are only really concerned with 3.

If we get 'na' as a response, the Queue is offline in Sametime, or it isn't a valid queue. This means our server can't see it. For this we are writing out to the Chrome/Firebug console Queue is offline, or doesn't exist.
If we get 'STATUS_ACTIVE', our server can see the queue, it's online. For this we'll write out Queue is online.
The other response we'd want to check for this the 'STATUS_AWAY' response, this means that the queue is online, but that all experts are currently busy.

Inside these if statements, you could write your own code to execute when these status' are returned. You could have this function load with the page, and if the server returns 'na' you could disable the chat button and give a message the the chat feature is currently disabled.

The other API call which we have surfaced is a way for you to get the number of available experts in the requested Queue. The code itself is almost identical to the code above, except we are requesting a different API endpoint URL:

http://<FQDN of Queue Manager Server>/ITFramework/webclient?getQueueExpertsReady=<Queue-Login-ID>

The JavaScript below lays out this API call simply.

getAvailableExpertCount: function (queueID) {
    var url = "http://192.168.1.214:8080/ITFramework/webclient?getQueueExpertsReady=" + queueID; // Change this to the FQDN of your IQM server

    $.ajax({
        url: url,
        type: "GET",
        complete: function(result){
                count = $.trim(result.responseText);
                console.log("Experts available: " + count);
        }
    });
}

Just like the first block of code, we set a URL using our FQDN and Queue ID, and perform a simple AJAX GET to the URL that we built. We trim the response, and console out the number of experts that we have in the Queue available. This response could be set into a variable itself, which maybe you would want to include in a counter somewhere on the page to show visitors how many agents are there to help. Because this is all JavaScript, it is very flexible to wire these API calls into your website to perform some basic to advanced tasks.

Using JMX to Investigate Queue Manager and Java on Linux

noreply@blogger.com (Instant) — Tue, 08 May 2012 15:00:00 +0000

Recently, we have been involved in a rather large Queue Manager deployment running on a Linux environment. During this process, we have been reviewing various tools and techniques to help analyze and detect issues in a remote production environment. As part of this process, we discovered the value of JMX, VisualVM, and the tools associated with debugging Java applications. Most of these practices are useful on both Linux and Windows deployments.

As a bit of background, our Queue Manager for Sametime application is built using Java and a collection of Java libraries. Queue Manager leverages the Sametime Java API for access to the core Sametime services, it uses the Domino libraries for accessing Lotus Notes/Domino services, and Queue Manager uses Spring as the main application framework. So, at a high level, Queue Manager is a Java Spring application running under Tomcat.

Typically, we deploy Queue Manager on a Windows OS. However, during a recent deployment, we configured Queue Manager to run on a Linux server. As part of this deployment, we wanted to remotely monitor the thread activity of the application, the CPU usage of the application, and identify any issues related to either thread usage or memory management.

While there are some very useful tools (typically command line) to help with this type of analysis, we particularly like JMX and VisualVM. After enabling JMX on the server hosting Queue Manager, our application developers then connect to the JMX monitoring system using VisualVM. This allows our developers to monitor the performance, health, thread usage, and memory usage in real-time - using a very nice graphical display. The added advantage is that we can use VisualVM to both remotely monitor a variety of internal servers, as well as use VisualVM to review thread dumps and heap dumps (memory allocation dumps) from a remote production environment.

Here is a screen shot of VisualVM monitoring an internal Linux instance of Queue Manager:

VisualVM is also very useful during extended periods of load testing and stress testing. Our internal developers created a variety of load testing tools in order to simulate the various Queue Manager users and systems. Our load testing suite includes the ability to scale the number of inbound Sametime IM seekers (people looking for help), the number of experts in a queue, the number of web service requests to the system, as well as experts entering and leaving various queues. During these load tests, VisualVM provides a real time display of the threads, memory, and CPU usage for the system.

In addition to high level monitoring, VisualVM enables the ability to sample (collect) data over a specific period of time. So, during certain load testing cycles, we can enable VisualVM to sample the activity of the system and then we can review the data to inspect threads, CPU usage across threads, and memory allocation.

View CPU usage by thread:

One of the most useful tools in VisualVM is the ability to dump threads. To create a thread dump, right click on the JMX instance and select Dump Threads...

Snapshots and System Sampling:

While the ability to capture a thread dump is useful, we have found the ability to save and export a snapshot of the system, using the sampling module, to be incredibly valuable. The 'sampler' area of VisualVM provides the ability to 'snapshot' the current system state and then export this information.

Navigate to the Sampler tab and enable sampling:

Click the Snapshot button

Export the snapshot

Save the snapshot as a file (so it can be shared)

The exported snapshot may then be transferred to another machine and opened using VisualVM. The ability to save profile snapshots, transfer these snapshots, and then inspect the snapshots using VisualVM has proved extremely valuable.

We have found JMX and VisualVM to be invaluable tools during both our internal load testing and remote performance tuning and analysis efforts. JMX is a standard component of the Java environment, and the addition of VisualVM provides a compelling, and powerful, collection of debugging and analysis tools.

Here are some helpful links that we have collected during this process:

VisualVM and JMX

Pretty good Spring presentation on JMX and other useful topics:

http://www.springsource.com/files/uploads/tomcat/tomcatx-troubleshooting-production.pdf

Getting started with VisualVM:

http://visualvm.java.net/gettingstarted.html

20 Linux System Monitoring Tools Every SysAdmin Should Know:

http://www.cyberciti.biz/tips/top-linux-monitoring-tools.html

Tomcat Related Links:

Reviewing Tomcat Configuration and Tuning:

http://www.devx.com/Java/Article/32730/1954

Presentation by Mark Thomas on Tomcat Tuning:

http://people.apache.org/~markt/presentations/2009-04-01-TomcatTuning.pdf

Mulesoft article on Tomcat performance tuning:

http://www.mulesoft.com/tomcat-performance

Misc:

Analyzing thread CPU usage on Linux:
http://publib.boulder.ibm.com/infocenter/javasdk/tools/index.jsp?topic=%2Fcom.ibm.java.doc.igaa%2F_1vg0001475cb4a-1190e2e0f74-8000_1007.html

Checking for looping code:

http://publib.boulder.ibm.com/infocenter/javasdk/tools/index.jsp?topic=%2Fcom.ibm.java.doc.igaa%2F_1vg0001475cb4a-1190e2e0f74-7fff_1001.html

Using JavaDump:
http://publib.boulder.ibm.com/infocenter/realtime/v1r0/index.jsp?topic=%2Fcom.ibm.rt.doc.10%2Fdiag%2Ftools%2Fjavadump.html

Alternate ways to get Java thread dumps:
http://dev.day.com/content/kb/home/cq5/CQ5SystemAdministration/TakeThreadDump.html

Reviewing socketinputstream threads:
http://javaeesupportpatterns.blogspot.com/2011/04/javanetsocketinputstreamsocketread0.html

IMtegrity 5 Product Launch - Continued Commitment to IBM Sametime

noreply@blogger.com (Instant) — Fri, 04 May 2012 15:49:00 +0000

At a time when many of our competitors are exiting the IM compliance and e-discovery market, Instant Technologies is continuing to invest, innovate, and extend our product offerings for IBM Sametime. Yesterday, we announced the immediate availability of IMtegrity 5. IMtegrity 5 continues to build on the outstanding platform that we have developed for compliance, archiving, and e-discovery for IBM Sametime.

IMtegrity 5 is a major product release for Instant and represents our commitment to our customers and the IBM Sametime user community. In addition to adding native support for Sametime 8.5, IMtegrity 5 includes two significant features that have been requested across a large community of our install base. First, IMtegrity 5 adds the ability to create ethical IM firewalls within an organization. By providing a real-time monitoring service for IBM Sametime, IMtegrity now has the ability to detect, and optionally prevent, Sametime IM conversations between individuals and groups. The ability to support ethical walls has been requested for many years and we are excited that we can now deliver this level of functionality to our customers.

In addition to ethical firewalls, IMtegrity 5 adds support for configurable IM disclaimers. These disclaimer notifications are designed to notify chat participants whenever new IM conversations are initiated. Disclaimer text may be customized for the local language and may be triggered based on a set of rules or actions. Many of our large customers have been requesting individual IM based disclaimers and we anticipate that this additional feature will help IMtegrity continue to gain momentum into new markets.

IMtegrity has always been based on simplicity of design, the ability to scale within large deployment, and the development of a stable platform for compliance and e-discovery. This latest release of IMtegrity continues this tradition of design and simplicity and includes a seamless installation process for Sametime 8.5 servers, a highly scalable archiving engine, and new features that will enable the IMtegrity platform to meet the demands of new and existing customers.

Our customer base for IMtegrity continues to grow as does our investment in the core IBM Sametime platform.

Peyton McManus
May 4, 2012

Good Presentation on Installing Sametime 8.5.1

noreply@blogger.com (Instant) — Thu, 03 May 2012 12:20:00 +0000

This is a pretty concise presentation (converted to a pdf) detailing the steps to install Sametime 8.5.1. The presentation is from Lotusphere 2011 and was presented by Frank Altenburg and Volker Juergensen.

http://www-10.lotus.com/ldd/stwiki.nsf/xsp/.ibmmodres/domino/OpenAttachment/ldd/stwiki.nsf/6F6353B28F5FB51185257775007AC431/attach/FINAL_SHOW201.pdf

Apache Tomcat 6 Shutdown Failure Resolution on SUSE Enterprise 11

noreply@blogger.com (Instant) — Tue, 01 May 2012 19:44:00 +0000

Recently, in a development environment, and customer site production environment we noticed some issues shutting down Apache Tomcat for our Queue Manager product running on SUSE Enterprise Linux 11. Running './catalina.sh stop' appeared to work fine, but upon further inspection, it failed to stop it's running Java process, and it left its PID file behind (/var/run/tomcat6.pid). Running the '/etc/init.d/tomcat6 stop' command showed us that, in fact, there was an error in the shut down process.

Review of the catalina.out log file revealed a permissions error writing one of the logs. The log entry itself wasn't terribly helpful, but the implications of a permissions issue were intriguing. It's important to mention that we installed Tomcat 6 using SUSE's YaST tool, we hadn't built it from source, so permissions problems shouldn't be an issue. After inspecting Tomcat's directories, I decided to explicitly give group execution privileges to the folders. The folders were already set to attributes 755, so that didn't appear to be an issue. I used the commands below for the Tomcat directories.

Before starting Tomcat again, I removed the PID file (/var/run/tomcat6.pid), killed the left behind Java process (using kill), and cleared out our logs. Once Tomcat was started, and everything was running smoothly, we sent the shutdown.

This time it shut down fine. Upon further inspection the spawned Java process that had lingered before was gone, as was the PID file. Further inspection of the logs showed no further errors with Tomcat's shut down either.

Enabling Calendar Sharing in Office 365

noreply@blogger.com (Instant) — Tue, 17 Apr 2012 16:02:00 +0000

We recently worked with a customer who moved their mailboxes to the cloud, and now run their organization on Office 365. Mailbox migration was smooth, but enabling calendar sharing (vital requirement) proved to be a larger task. After reading tons of Microsoft Technet articles and posts, we were able to get calendar sharing/permissions all sorted out (disabled by default in Office 365). Read the full blog article to follow the steps, a word of warning though, we'll be using Powershell today.

To start, you'll need to install and configure the Microsoft Online Services Module for Windows PowerShell . You can follow the instructions here to do so, it's easy enough.

Next we'll want to open the Microsoft Online Services Module for Windows Powershell program. It will launch like any other Powershell program. Once loaded, we need to give Powershell the credentials we'll be logging in to Office 365 as. These need to be for a user with Administrator privileges in your Office 365 domain. To do so, run the following command:

$credentials = Get-Credential

This will spawn a window asking for credentials, enter your Office 365 administrative credentials.

Once Powershell has your credentials, we need to log into the Office 365 servers using the credentials we just set, and start our remote session. Use the command below to do so.

$session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://ps.outlook.com/powershell -Credential $credentials -Authentication Basic -AllowRedirection

This might take a few seconds to complete.

Next, we need to lower our shell security. This enables us to run the cmdlet after this which executes a script from Microsoft’s servers. Use this command to do so:

Set-ExecutionPolicy -ExecutionPolicy unrestricted

Now we need to import the Powershell commands, from the Microsoft servers, to our local session. Use the command below to do so.

$ImportResults = Import-PSSession $session

Once that finishes, we should restore our default shell security. Use the command below to restore our default Execution Policy.

Set-ExecutionPolicy -ExecutionPolicy restricted

All that's left now is to turn on the calendar sharing. It's a longer command, but it will set a default policy for enabling calendar sharing across the domain.

Set-SharingPolicy ‘Default Sharing Policy’ –Domains ‘*: CalendarSharingFreeBusySimple’

You can now exit Powershell using the 'Exit' command. Sharing has now been enabled across your organizational domain! Users can now publish their calendars, and share them with other users. Feel free to comment below if you run into any issues.

Enabling the Sametime Connect Web API in Lotus Notes Installations

noreply@blogger.com (Instant) — Wed, 21 Mar 2012 20:42:00 +0000

In prior posts we've discussed some advanced functioning that can be performed using some JavaScript/jQuery and the Sametime Connect Web API/SDK. This all works just fine unless you are using Sametime from within a Lotus Notes client, in which case none of these examples will work. By default, the Sametime Connect Web features (port/servlets) are disabled by the client and need to be turned on. Thankfully, it's a straightforward process to enable it, an you can follow the steps below to do so.

Open the following file '<Notes install directory>\framework\rcp\plugin_customization.ini'.
Modify the entries to mirror our versions below:

com.ibm.collaboration.realtime.webapi/startWebContainer=true
com.ibm.collaboration.realtime.brokerbridge/startBroker=true

Save the file.
Restart the Lotus Notes client.

That's all it takes. Once the steps above have been completed the port that we call during our API calls is open, and the Web API is online.

Improving the Sametime Connect Web API (a bit) with a Dash of jQuery

noreply@blogger.com (Instant) — Thu, 09 Feb 2012 18:22:00 +0000

Previously, we discussed using some of the features built in to the Sametime SDK/Connect Web API to check the presence of a user, or in our case a queue, before initiating a conversation through an internal portal page. At a high level, our 'click to chat' web application needs to detect whether a Sametime Connect client is available, or whether we should initiate a conversation using our web client. We checked the user's presence before starting a conversation because we found, in some cases, that the Sametime web API wouldn't be able to tell if a user was online or not, and an attempt to launch a Sametime conversation to that user (or queue) would invariably fail, so we needed to launch our web client in these cases.

The previous blog post resolved a lot of our problems with presence detection, but it also uncovered some additional issues related to successfully detecting whether to launch our web client or the native Sametime client. More specifically, our custom Instant.detectPresenceOfUser(' [user] ') JavaScript function would work fine (and would return true indicating that Sametime could see the user online) and it should therefore be able to launch a Sametime conversation with that user. However, this is where the trouble begins; even though our code would detect a native Sametime client, the Sametime window would never appear and our web client would launch by default. In most test scenarios we would get the web client about 4 out of 5 times (even when the person had a local Sametime client installed). Clearly there was an issue in the API code for invoking the Sametime window.

Below you will see the code as it exists in the Sametime Connect Web API, the function is called sametime_invoke, it takes in a series of parameters which we will lay out below.

 var sametime_invoke = function(action, userId, params)  
 {  
      var d = new Date();  
      var url = sametime_servletUrl + action+'?userId='+userId;  
      if(params != null)  
           url += "&" + fixupParams(params);  
      url += "&time=" + d.getTime();  
      var imgObj =new Image();  
      imgObj.src = url;  
 }

First, the function requires an action, in our case, chat. Next a userId, following the same example as our previous post, System p. And last it takes in some optional parameters which we aren't using. So normally, our JS to invoke the Sametime client would look like this:

 sametime_invoke('chat', 'System p');

This would launch a chat conversation with the 'System p' user. Through our testing though, this sametime_invoke function proved to be deficient, working properly only a handful of times. Looking at the sametime_invoke function, it appeared as though the last two lines of the function are where the magic request happens to spring the window. Stepping through the function logically, we can follow it like this:

  var sametime_invoke = function(action, userId, params)   
  {   
    // Creates a new JavaScript Date object, this is used later to create a timestamp   
    var d = new Date();  
      
    // Forms the URL which it will post to, using the parameters we passed in (action, userId, params)   
    var url = sametime_servletUrl + action+'?userId='+userId;  
      
    // Looks to see if we have passed in parameters  
    if(params != null)  
       url += "&" + fixupParams(params); // Appends them to the URL  
      
    // Adds a timestamp to the end of the URL using the Date object (d) we created above.   
    url += "&time=" + d.getTime();  
      
    // Creates an image object on the page  
    var imgObj =new Image();   
      
    // 'Loads' the image using the URL we built. This makes a request to the URL, and should open the window.   
    imgObj.src = url;  
  }

The issue with inconsistent launching appears to come from the last two lines. The creating of the Image object, and staging the image request to the URL provided doesn't appear to be the best approach to this. It also lacks the ability to detect any failures, its essentially a blind post. That being said, all of the code leading up to those two lines, is very useful, and tells us quite a bit about what the Sametime client's servlet requires in order for us to make a POST (or in our case, for this article, a GET) to launch that window.

By visiting the URL that it builds (http://localhost:59449/stwebapi/chat?userId=Demo%20Sales&time=1328650958738, for our purposes), we get a launched Sametime client chat to our 'Demo Sales' queue, and we also get, in the browser, a response from the servlet, formed as parsed JSON (JSONP). This is very useful. This response (returnCode:200), lets us know that the servlet understood our request, was able to find the user, and launch the Sametime window. Unfortunately, this doesn't help us detect presence, so if the user is offline, it'll still launch the window, it will just error once it does saying the user is offline. So we will still need to do those presence checks up front using our Instant.detectPresenceOfUser function.

So, enough talk about it, lets re-write that sametime_invoke function using jQuery, AJAX, and a callback function.

 Instant.launchSametimeConversation = function (stid) {  
   var time = new Date();  
   var getUrl = 'http://localhost:59449/stwebapi/chat?userId=' + stid + '&time=' + time.getTime() + '&jsonp=Instant.handleResponse';  
   
   // Use jQuery to request the Sametime servlet URL. If a request makes it to the URL successfully, the servlet will return a code 200 and open the Sametime client chat with the user.  
   // We use the Instant.handleResponse() function as a callback to process the JSONP data object that the servlet hands back.  
   $.ajax({  
     type: 'GET',  
     url: getUrl,  
     dataType: 'jsonp',  
     jsonpCallback: 'Instant.handleResponse'  
   });  
 };  
   
 // A rudimentary callback function to handle JSONP data objects retrieved by the Instant.launchSametimeConversation() function.  
 Instant.handleResponse = function (data) {  
   if (data.returnCode === 200) {  
     alert('Success!');  
   } else {  
     alert('Failed!');  
   }  
 };

In the functions above, you an see that we follow the same approach initially as the bundled sametime_invoke function, but stray heavily once we are staged up.

First, since we are always using chat, and never using the custom parameters, we strip the function parameters down to just stid (the username) of the user we are chatting with. We bundle the rest of this into our getUrl variable, along with the timestamp. We did add something new though, you'll notice the '&jsonp=Instant.handleResponse' parameter at the end of the URL. This specifies our callback function to the servlet. Normally, jQuery handles this fairly well, but the Sametime servlet we are posting against seems fairly specific with how this needs to be formed, so we include it in the URL. We also include it into the jQuery $.ajax method.

Our callback function is very simple for this example. It could be made much more complex though, simply by providing extra checks for different return codes, and added functionality based off of those checks.

After rebuilding this function, and adding the callback function, we are able to have much more control over how we launch the Sametime client window, and are able to check for failures finally. This function also consistently launches the Sametime client chat window when expected and hasn't failed to do so yet. The only two requirements are to have a Sametime client logged in, and to have the jQuery library linked in to the page that will house the above functions.

I'll post screenshots of the success below, as well as a GitHub gist of the code. Reach out to me at zclancy@instant-tech.com with any questions/comments.

Integrating Instant Alert Manager for OCS and Lync with Email

noreply@blogger.com (Instant) — Wed, 25 Jan 2012 19:21:00 +0000

Instant Alert Manager for OCS and Lync provides a server based alerting engine and notification system for Microsoft Lync and Microsoft OCS. Our application is capable of dispatching a series of instant messages (IMs) to users - typically this is used to notify people who are running either Microsoft Lync or Microsoft OCS of some event (i.e. a system outage, the status of a help request, etc.).

We have developed Alert Manager with an extensible API - with the idea that other systems might want to dispatch messages using our framework. Recently, a prospective customer requested the ability to integrate an email notification system with our IM dispatching system. At a high level, our application will monitor a mail box and will immediately dispatch the messages to a set of online users running OCS or Lync - as the messages are received by the mail system. The idea is provide a single inbound notification bridge, via an email account, and then immediately alert the correct set of people using IM.

So, several days after the initial request, we have developed a new listening service that integrates our alerting system with a POP3 mail account. This new listening service will monitor a mail account and immediately dispatch inbound mail messages to an appropriate group of users who are online in either Microsoft OCS or Microsoft Lync 2010.

Here is a screen shot of the mail account - with a message pending:

This is a sample message - where the message is currently encoded as XML.

After the email is received, our new email listening service parses the message and dispatches the request to Alert Manager - where it is placed in queue for immediate delivery.

As soon as the message is placed into the dispatching queue, it is staged for delivery - awareness for the recipient(s) is verified, and then the message is delivered using either Microsoft Lync 2010 or Microsoft OCS.

Setting up a TrustedApplication for Lync 2010

noreply@blogger.com (Instant Support) — Wed, 25 Jan 2012 14:08:00 +0000

Open Lync Management Shell
Create TrustedApplicationPool

Run Get-CsSite. Note SiteId
Run Get-CsService –Registrar. Note Identity:Registrar:
Run New-CsTrustedApplicationPool –Identity [LyncServer] –Registrar [Registrar] –Site [SiteId]
Run Enable-CsTopology

Run New-CsTrustedApplication – Save these settings, as you will need them to configure BLM

ApplicationId: Supply a descriptive name here
TrustedApplicationPoolFqdn: The fully-qualified domain name of the trusted application pool created in the previous step. Can be found by running Get-CsTrustedApplicationPool
Port: Select a port to access the trusted application. Should be >1024. Be sure that the port is open on your firewall.
Run Enable-CsTopology to commit the changes
Run “Get-CsTrustedApplication > [some file name].txt” This will save the information you will need to configure BuddyList Migrator to a text file, as it is very difficult to copy from the Management Shell.

Setup TrustedApplicationEndpoint

Run New-CsTrustedApplicationEnpdoint –ApplicationID urn:application:yourAppname –TrustedApplicationPoolFqdn appPoolFQDN –SipAddress sip:name@domain –DisplayName “Name”

Setup Certificates for the machine on which you will install BuddyList Migrator. If installing to the Lync Server, this can be ignored

Run mmc
Add the Certificates snap-in. Select “Local Computer”
Go to Personal->Certifcates
Action->All Tasks->Request New Certificate
Continue through the Wizard. Select “Computer” for the type of certificate.

Checking the presence of a user (or queue) in Sametime using JavaScript

noreply@blogger.com (Instant) — Mon, 02 Jan 2012 20:19:00 +0000

Recently, while tracking down a potential bug in one of our Queue Manager deployments, it was decided that we needed a way to check the presence of a logged in user through the Sametime Connect Web API. For instance, while on a website an end user clicks on a ‘Live Chat’ link, they are logged into a Sametime client on their computer, so we use JavaScript to talk to that Sametime client to get a bit more information. We check with the Sametime client to see if our ‘Live Chat’ support queue (user) is online, if the Sametime client can see that user online, we will start the conversation through their installed Sametime client, if it can’t, we will launch our branded web client so the conversation can still happen.

After reading through the Sametime SDK/Connect Web API documentation fairly extensively, I determined that there was no real official or right way of doing the above on the client side with JavaScript, so we’d have to improvise a bit, piecing different parts of the API together to get it to do what we wanted. Let’s look at some code.

The first thing we needed to do was wire up some Sametime livenames. According to the documentation, livenames are a UI representation of a contact; they display the online status using a status icon, and bold coloring of the contact’s display name. To do this, we include the getStatus.js JavaScript file; this file exists inside the user’s local Sametime client, and includes a lot of utility functions to deal with livenames/presence.

<script type="text/javascript" src="http://localhost:59449/stwebapi/getStatus.js"></script>

The Sametime client listens on http://localhost:59449, so if the user currently has Sametime running, these files will exist for us to include in our HTML/JS pages.

The next step is to add some HTML links for the users which we’ll be checking presence on. For our use case, we didn’t want these links to appear on the page, we just wanted our JavaScript and the getStatus.js file provided to utilize them as needed, so I added a style=”display: none;” tag to the link to hide it. These links need to have the class=”awareness”, as that is how the getStatus.js file will pick them up when the page loads.

<a class="awareness" userId="System%20p" style="display: none;">Resolving contact, please wait....</a><br />
<a class="awareness" userId="zac" style="display: none;">Resolving contact, please wait....</a><br />
<a class="awareness" userId="test user" style="display: none;">Resolving contact, please wait....</a><br />

The userId=” {username} ” denotes the user which we are tracking presence of. In the example, we have System p (one of our test support queues), zac (my internal username), and test user (a non-existent user which will show up as offline).

After saving the file, we can access the HTML page we created. It will appear blank, but if we have Sametime running, we should be able to see some things under the covers in the browser. Using Firebug, we can see that the getStatus.js file has built up an array, called sametime_livenames, where it has stored a bunch of values about the users which we added to the page.

Now that we have these populated objects, let’s see how we can manipulate them to get a presence. In this example, we have three users; two (System p, zac) of them online, 1 (test user) that is offline. Now that we have sametime_livenames built up, we need to find the user’s presence. This took some serious digging on my part to find the differences, and good ways of doing this. I eventually settled on the fact that if the user is online, a “_properties” variable will be defined, if the user is offline, this variable doesn’t exist. Below is the Firebug output that lead me to this while testing.

sametime_livenames[0]._properties represents the first user we are tracking, System p, which is logged in.
sametime_livenames[2]._properties represents the last user we are tracking, test user, which is not logged in, and returns undefined.

So now we know what we are looking for to detect presence, but we need this to happen automatically when a user clicks a link, and have some custom logic to determine which chat client to launch, so let’s build our function to do this.

We will be using object literal notation since we don’t want our JavaScript to interfere with any other libraries the site we post to may be using.

// Detect presence of watched Sametime users
Instant.detectPresenceOfUser = function (stid) {
    user = stid.toLowerCase(); // Convert stid variable to lower case for switch statement

    switch (user) {
        // Check if STID is System p
        case 'system p':
            livename = sametime_livenames[0];

            // Check if user is logged in
            if (typeof livename._properties === "undefined") {
                return false;
            } else {
                return true;
            }
            break;
        // Check if STID is zac
        case 'zac':
            livename = sametime_livenames[1];

            // Check if user is logged in
            if (typeof livename._properties === "undefined") {
                return false;
            } else {
                return true;
            }
            break;
        // Check if STID is test user
        case 'test user':
            livename = sametime_livenames[2];

            // Check if user is logged in
            if (typeof livename._properties === "undefined") {
                return false;
            } else {
                return true;
            }
            break;
    }
};

The Instant.detectPresenceOfUser function is where we will return a true/false based on whether or not the user that we pass into the function is online or offline. The user gets passed in (ex. Instant.detectPresenceOfUser(“System p”);), the function converts it all to lower-case, and then passes it through the switch which determines what user we are looking for the presence of. Next, it checks that _properties variable, if it exists, the user is online, and the function returns true, otherwise, it returns false as it can’t see the user.

This gets bundled into our Instant.startChat function, so that we can have some logic about how we want to start the conversation. Now, if the website can’t see the user when a chat is initialized, it will launch the web client. In our case, the user may not be offline, just the site can’t see them, and the web client will bridge that gap.

Our full file of JavaScript utilities can be seen below. This includes checking whether the user is running Sametime, the presence detection function, and the function that can start a chat conversation from the web using Sametime.

Instant Profile Manager

noreply@blogger.com (Instant Support) — Thu, 08 Dec 2011 17:12:00 +0000

Have you ever wished that it was easier to switch between accounts in Microsoft Communicator?

Having to do this every time you switch accounts is less than ideal...

Here at Instant Technologies, we've been doing a lot of work of late around Microsoft Lync 2010. One minor, but irritating issue that we have faced is that there isn't really a good way to switch between accounts on the vanilla Lync Communicator client. For the typical Lync user, that's probably not a big concern, but in our development environment, it becomes irksome rather quickly, particularly since it is not possible to run multiple instances of the client at the same time. Some sort of tool to automate logins, and preserve more than a single set of credentials would be very helpful for in-house testing and development purposes.

We decided to spend a couple days ginning something up that we could use internally, and add another Microsoft API to our toolbox in the process. It's proven fairly useful for testing and development here, and so we have decided to release it to the community.

Instant Profile Manager in action

Features:

Stores log in credentials for an arbitrary number of Lync accounts.
Passwords can be stored, or, if you prefer, you can be prompted each log in.
Option to manually set the fully-qualified domain name of the server pool, so that you can easily switch between users on different pools.
Log in to a Lync account with just a couple clicks.

Here is a video demonstration of Instant Profile Manager in action. link

Setting up a profile in Instant Profile Manager

Requirements:

Microsoft .Net Framework 3.5
Microsoft Lync 2010 Communicator Client

Download Link: Instant Profile Manager (ZIP)

If you're interested in how we did it, read on...

Technical:
As it turns out, it is relatively simple to automate logins to the Lync Client, using the Microsoft Lync 2010 SDK (SDK, Docs). The heavy lifting is mostly handled by the LyncClient class, which exposes functions to sign in and out, and (although we haven't explored it yet) it would appear contact management and messaging are available as well.

We save the profile list as XML, to the current user's My Documents folder. It'a a dead-simple implementation, using the .Net XmlSerializer to handle transforming our list of Profile objects into XML for us.

Since the Communicator client sets a registry key (HK_CurrentUser/Software/IM Providers/Communicator/UpAndRunning), it is a simple matter to check, and then launch the client if it is not running. One caveat, for users with 64-bit systems, or who have installed Lync to a non-default location: You will need to edit ProfileManager.exe.config and set "PathToClient" to point at the location your communicator client is installed to.

We made an effort to also support OCS 2007 R2, as we also have a number of products that we regularly test targeting that platform, but by all indications, the Microsoft Office Communicator 2007 SDK doesn't work, or at least not with the 3.5.6907 version we are using. Specifically, the IMessenger.Signin method doesn't seem to do any more than pop the client window up, regardless of the values passed as parameters. Perhaps this once worked, as there are a number of examples citing it (see Programming for Unified Communications, Chapter 3), but it is now marked deprecated, suggesting that IMessenger.AutoSignin() be used instead, which is wholly unsatisfactory for our purposes. While there appear to be some hacks one can do to make a Lync Client connect to an OCS 2007 R2 server, we didn't have much luck, and so had to abandon the idea of supporting 2007.

Queue Manager - New Charting Options

noreply@blogger.com (Instant) — Thu, 06 Oct 2011 22:00:00 +0000

In response to several customer requests, we are extending the measurements and reporting area of Queue Manager to support some additional charting options. One new option will be the ability to chart information based on a selectable date range.

For example, all queue traffic between the dates of October 1, 2011 and October 6, 2011.

Will produce the following chart - which may also be exported to Excel:

In addition to these new charts, the next update for the charting system will provide:

Dual axis charting (so you can chart 2 data sets - for example queue traffic v. % connected)
Ability to display all questions submitted before entering a queue (it would be cool to display trending topics)
Date selectable charts
New views to show connected/unconnected requests as well as resolved/unresolved requests
Charts to display cumulative chat time for experts as well as queues

Thank You SaskEnergy for a Great IMtegrity Case Study

noreply@blogger.com (Instant) — Fri, 09 Sep 2011 18:25:00 +0000

We'd like to send a special 'Thank You' to SaskEnergy for their help with our recent IMtegrity case study - focused on Sametime chat logging as well as Sametime charting and reporting.

As a company, we know that IMtegrity is an excellent application and is a great fit for customers looking to log and archive Sametime chat conversations. However, it's even more important when a customer uses their own words to express their experience with the product and their requirements.

So, thank you SaskEnergy for an excellent case study on Instant IMtegrity and your selection of IMtegrity as your Sametime chat archiving application. SaskEnergy is also an early adopter of Instant's Charting and Reporting suite for Sametime.

It was a pleasure working the entire team at SaskEnergy and we appreciate their support and encouragement.

Queue Manager Charting Updates

noreply@blogger.com (Instant) — Thu, 08 Sep 2011 16:28:00 +0000

Based on some recent customer deployments, we have added some features to our charting plaform and provided several new charts, and one new chart type, to our charting module for Queue Manager. In summary, we have added the ability to:

Capture and log usage metrics for both queues and experts
New charts to view usage metrics for queues and experts
A New chart type to layer 2 datasets in one chart
Several new charts to display comparisons of various metrics within one chart

Since many of our customers deploy Queue Manager within a help desk environment, one customer requested mertics to determine how long help desk experts spend in actual chat conversations with customers. We have therefore added several new charts that will provide metrics on chat duration, and usage, for both experts and queues.

Here is a sample chart that demonstrates the chat duration for a collection of experts. These new drill down enabled charts should provide a more detailed set of metrics on how long experts spend in actual chat conversations.

In addition to metrics on usage, we are providing the ability to compare 2 metrics within on a single chart. For instance, display the total number of conversations for a queue as well as the percentage of inbound requests that were successfully answered (Total Requests v. % Answered). We have added a new base chart type that will allow us to layer 2 data sets within one chart.

Here is an example of a chart that displays 2 sets of metrics

Queue Manager continues to gain great traction within environments that need a click to chat solution leveraging Lotus Sametime. With these new metrics, and chart extensions, we continue to expand our help desk platform for Lotus Sametime environments.

Social Communities and Collisions of Culture

noreply@blogger.com (Instant) — Fri, 02 Sep 2011 17:22:00 +0000

Like the phrase Web 2.0, the term Social is a loaded term with some room for interpretation. In a world where everyone is tethered with an IP address at all times, it becomes relatively easy to communicate with anyone, anywhere, at any time.

In the old days, like the early 1990s (well, pre 1990), email was pretty standard, but it was typically transmitted over modems that connected to various service providers and then blasted out, and took in, the mail packages for that period. In this semi-connected world, email made sense – and so did a plain old telephone call. This is probably what we refer to as the early Internet era.

In the next transition, most companies became constantly tethered to a service provider and simultaneously deployed internal networks throughout their organization. Here, the organization had a pretty stable collection of IP addresses, employees had internally assigned IP addresses, and folks could easily connect within, and across, organizations. This may broadly defined the Internet boom and bubble of the late 90s – extending through web 2.0.

In this new phase, everyone is tethered with an IP address at all times. Typically, most people have more than one IP address – one for work, one for a work phone, one for a personal phone, and one for their home. My 8^th grader has a phone that essentially provides him with an IP address at all times. At most times during the day, most folks probably have at least two, or possibly three totally different IP addresses that they can use to communicate. This tethering, and multi-tethering of IP addresses providing an inherently personal experience is what I consider social.

So, Social may be thought of a ubiquitous access to either one, or two, IP connections. This connection, or collection of connections, provides access to both a personal community and a professional community – active and available at all times. Applications are then pushed to various end-points (mobile, desktop, tablet, etc) to bridge these various social and personal communities. Currently, this explosion seems have focused on connecting (or reconnecting) fundamentally personal relationships and personal communities (i.e. friends from high school, colleagues from previous companies, classmates).

It is interesting to imagine what happens when we experience a collision of these various communities and networks – read differently, a collision of cultures. What takes place when the personal community collides with the corporate community – both operating in real-time? Does one fracture or absorb the other? What happens when the communities within a corporation are extended, or possible relocated, and placed into a personal or social space? How are new channels created in the corporate community to absorb, mine, and manage the personal networks that are developing in the social landscape? In this ‘post social’ space, these networks of networks collide, transform, are managed, created, and potentially shift from corporate, to social, and back again.

Lotus Notes as a Platform

noreply@blogger.com (Instant) — Wed, 31 Aug 2011 16:34:00 +0000

Recently, we have been exploring different software platforms as possible alternatives for our future development efforts. As with all platform choices, it's not an easy decision. However, as I have been thinking about this, I've had some soul searching around using Lotus Notes as a platform - which for all practical purposes, we have been using for many years.

These possible platform choices kinda look like this:
Spring + SQL variant
Spring with Groovy and Grails + SQL variant
Ruby and Rails
Node.js (maybe with CouchDB)
Microsoft .net + SQL Server and IIS

While I can debate the merits of all of these platforms, the one 'platform' that we are cautiously re-evaluating for future development is Lotus Notes. That is a bit strange, since Lotus Notes is inherently a platform - and a pretty awesome platform at that. Notes includes some great stuff - most of which is just starting to show up in other environments/platforms.

Let me count the things that I like about Notes (as a platform):

Fully functional and robust multi level security model - server, database, document, field level
A 'no sql' database without the pain of relational data models
A replicating database - that is really fast - even over slow connections
Internal directory management and hooks to all popular directories
Rich development environment including support for Java, xml, JS, Lotuscript, etc..
Nice deployment model (using templates and replication)
Server based management tools and very rich admin tools
HTTP stack - although the servlet container and other tools are dated
Ability to easily update development, testing, production environments by simply updating database templates and replicating databases
Stability and scalability

Here are many of the standard issues/platform consider impediments that we experience with Notes - most of which will familiar to folks in the Notes field.

We will only be able to sell into existing Lotus Notes shops
No good cloud based runtime model/hosting scenario - or good runtime model that works in 'non Notes' shops
Licensing is confusing and expensive
Young employees/prospective employees don't understand the platform or have any skills
I don't think IBM considers Lotus Notes as a viable platform and they (IBM) would like to see folks move to their industrial strength platform - Wepsphere

So, as we consider future platforms, and hear young developers espouse the virtues or Ruby/Rails, Spring, 'no sql' databases that just deal with name/value pairs, etc, I'm always brought back to the idea that many of these platforms are repurposes functionality that has been available in the Notes community for many years.

So, we will take the relatively safe approach and stick with Java, Spring, Groovy, JQuery, maybe some Grails, and then mount a standard SQL db under the covers. We will run under Apach/Tomcat and use standard libraries such as Log4J, Velocity, etc..

Peyton

Configuring Linux for the Notes API

noreply@blogger.com (Instant) — Tue, 26 Jul 2011 19:05:00 +0000

Recently, while installing/running some test Java applications, we came across the following error:

Exception in thread "AWT-EventQueue-0" java.lang.UnsatisfiedLinkError: lsxbe (Not found in java.library.path)

This was on a box running SUSE Linux Enterprise Server 11 SP1, with Lotus Notes installed as well as the Java 1.6 Runtime Environment.

Running 'echo $PATH' showed that while the Java Runtime Environment was in our system/environment path, none of the Notes directories were. To do this we needed to add to the default path that SUSE provides each user. This is controlled in a few places, but, the safest place to make adjustments is inside the .bash_profile file (located in the users home folder, create this file if it doesn't already exist).

Here's how it looked after we created and added to it:

PATH=$PATH:/opt/ibm/lotus/notes
PATH=$PATH:/opt/ibm/lotus/notes/jvm/lib/ext
export PATH

After restarting our shell and running 'echo $PATH' we can see the new additions to our users path. Running the application gave us the same error as above, so we hadn't fixed it yet. After investigating more into Lotus Notes, we found some more things that needed to be added to our path.

Here's .bash_profile with our new changes:

PATH=$PATH:/opt/ibm/lotus/notes
PATH=$PATH:/opt/ibm/lotus/notes/jvm/lib/ext
PATH=$PATH:$NOTES_HOME
export PATH
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/ibm/lotus/notes
export LD_LIBRARY_PATH

After restarting our shell, the test application ran fine, and the exception above was gone. This was all done as the root user, to push this file to other users profiles, use this command from your home folder:

cp ~/.bash_profile /home/{username of the user}

Just replace after /home/ with the user name of the user to push the changes to.

Automatically Create Active Directory Accounts for Microsoft OCS

noreply@blogger.com (Instant) — Tue, 01 Mar 2011 21:13:00 +0000

In order to load test one of our Microsoft OCS applications, we needed to quickly create hundreds of test accounts for one of our OCS servers. First, we created the accounts in AD, then we simply highlighted the new accounts and provisioned the accounts for our OCS server.

Here is a small vbs script to create the sample users:

Set oRoot = GetObject(LDAP://rootDSE)

Set oDomain = GetObject("LDAP://" & oRoot.Get("defaultNamingContext"))
Set oOU=oDomain.Create("organizationalUnit", "ou=OCS Test Users")
oOU.Put "Description", "OCS Test Users"
oOU.SetInfo

For i = 1 to 200

       Set oUser = oOU.Create("User", "cn=OCSTest User" & i)
       oUser.Put "sAMAccountName", "OCSTestUser" & i
       oUser.Put "Description", "OCS Test User" & i
       oUser.SetInfo
       oUser.SetPassword "password"
       oUser.AccountDisabled = False
       oUser.SetInfo

Next

Wscript.Echo "Success, Check Active Directory Users and Computers - Remember F5"

Here is a screen shot of the test users:

After selecting all of the users in the explorer, we used the action to automatically provision the users for OCS - and selected the 'use SAM account' option

Sametime Chat Logging - Customer Feedback on IMtegrity - Excellent

noreply@blogger.com (Instant) — Fri, 18 Feb 2011 21:29:00 +0000

At Instant Technologies, we have many award winning Sametime products. However, it's wonderful to speak with customers running our Sametime chat logging application, Instant IMtegrity, and hear the great feedback and real world usage scenarios. This week, in a great conversation with a recent customer, I learned that IMtegrity is being used in a an environment where the application is logging more than 1,000,000 Sametime IM conversations per month. We have plenty of deployments that handle 10,000 conversations a day, but hear the words 'more than one million' indicated a huge leap.

In addition to the pure volume of the Sametime IM conversations moving through the system, the nicest feedback involved the compliments related to the installation and support. In the words of our customer, the installation took 'less than 30 minutes' and didn't involve any 'additional services, complex configurations, or technical support'.

In the words of our customer, 'IMtegrity is rock solid, highly scalable, and does exactly what it needs to do'.

One million conversations per month, zero outages, and a very happy customer.

This has been a great week at Instant

Instant IMtegrity 4.13 Released

noreply@blogger.com (Instant) — Mon, 14 Feb 2011 18:02:00 +0000

In response to a customer issue, Instant has released a point upgrade of IMtegrity, our Lotus Sametime chat logging and compliance application. Instant IMtegrity version 4.13 addresses an issue encountered importing image files.

The point release is available to existing Instant Imtegrity customers who are current on support and maintenance. Information is available on the IMtegrity product page:

What's new in Instant IMtegrity 4.13:

Fixed error "Subscript out of range (#9)" when importing chat log files containing images.

Fixed another instance of error "Font size must be between 1 and 250, or STYLE_NO_CHANGE

(#4364)" when importing files with HTML formatting.

What's new in Instant IMtegrity 4.12:

Fixed error "Object variable not set (#91)" when merging transferred files starting with an

!exclamation mark in their file name.

Fixed error "Font size must be between 1 and 250

New Manager Functionality In Queue Manager V4

noreply@blogger.com (Instant) — Thu, 04 Nov 2010 19:35:00 +0000

Queue Manager V4 is receiving excellent customer adoption and deployments. In response to recent customer feedback, we are pleased to announce that we have extended the way that queue managers can add, remove, and adjust queue staffing levels.

Our new 'Manager' module offers queue managers a real time dashboard that displays queue activity (both historical and real time) as well as current staffing levels.

Managers can see how many people are waiting for an expert, how many experts are available, and which experts are provisioned to help within the queue.

This updated functionality is supported in the V1B67 build of the database (October 28, 2010).

What's new in Instant Archive Viewer build 3.0.49 - 3.0.55 for Microsoft OCS

noreply@blogger.com (Instant) — Fri, 01 Oct 2010 18:39:00 +0000

Instant Archive Viewer for Microsoft OCS
Instant's Archive Viewer for Microsoft OCS is a very useful tool to search, retrieve, and report on conversations and content within the Microsoft OCS system. Visit our website for more detail:
http://www.instant-tech.com/Archive_Viewer_OCS.cfm

What's New in Build 3.0.49 for Instant Archive Viewer for Microsoft OCS?

Instant Archive Viewer for OCS Version 3.0.49 is now available and comes with a gamut of helpful enancements and fixes. Here are five new items that have been introduced.

1. Charting and Reporting

Instant Charting and Reporting for Microsoft OCS will create animated, interactive charts quickly and easily in order to measure traffic in your Microsoft OCS system. Display high level information organized by year or drilled down to the hour; Quickly filter usage by users and export them to Excel; View browser based reports from LCSLOG, LCSCDR, QOEMETRICS, ACDDYN and RTCCONFIG OCS database tables hosted from SQL server. For more information visit our Instant Charting and reporting for Microsoft OCS Web page at http://www.instant-tech.com/Charts.cfm

View Live Live Demo
Download Instant Charting & Reporting for OCS Datasheet

2. Improved Active directory browsing

We've made some small changes to the Active Directory picker. The Active Directory picker is available on the Extended Search and Discovery tab of the Admin page for browsing users and groups to access the Extended Search and Search and Discovery Page. It is also available for searching users/groups in active directory to search key words in conversations.We now allow administrators to choose how you would like to find the users in Active Directory via a drop down menu. The drop down menu has three choices: First name, Last Name or login name/samacount name.

3. Time zone differences between server and local machine

This small updated feature allows the Instant Charting for Microsoft OCS module to compensate for the local time zone of the local machine viewing Charts when there is a difference in time zone between the Server and local machine. It is a setting located in the Basic Settings tab of the Administrator options page.

4. Enhanced debugging

Debug will now capture all information including read-write access and connection information. This is very helpful for configuration of Instant Archive Viewer for Microsoft OCS.

5. New look and easy navigation

Instant Charing and Reporting for Lotus Sametime

noreply@blogger.com (Instant) — Wed, 15 Sep 2010 17:25:00 +0000

We are proud to announce that we have started shipping our Instant Charting and Reporting application for Lotus Sametime. The applications combines our experience developing a great charting and reporting system for our Queue Manager, as well as our experience developing a robust and scalable archiving application for Lotus Sametime.

The charting and reporting application provides 3 main components:
1 - Charting information and statistics captured by our IMtegrity database and archiving application
2 - Charting information provided by the Sametime ST Logs. This is mainly for historical purposes and displays a variety of useful Sametime statistics against a historical period
3 - Live usage metrics and data: This information is provided using the Sametime Statistics Servlet and displayed in real time using some excellent charting tools.

A live demonstration of the application is available on our web site. Please direct any questions, or inquiries, to sales@instant-tech.com

A broader overview of the application, with screen shots, data sheets, and other information is available at:
http://www.instant-tech.com/lotus_sametime_charts.cfm